canopycms 0.9.0 → 0.10.0

package/dist/editor/admin/SystemHealthPanel.js

@@ -9,14 +9,15 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
  * only for admins (see isAdmin(userContext?.groups)); this component does not
  * re-check that itself, same as GroupManager and PermissionManager.
  */
-import { useRef } from 'react';
-import { Alert, Badge, Button, Code, Group, Loader, Modal, Paper, SegmentedControl, SimpleGrid, Spoiler, Stack, Table, Tabs, Text, ThemeIcon, Tooltip, } from '@mantine/core';
+import { useRef, useState } from 'react';
+import { Alert, Badge, Button, Code, Group, Loader, Modal, NumberInput, Paper, SegmentedControl, SimpleGrid, Spoiler, Stack, Table, Tabs, Text, ThemeIcon, Tooltip, } from '@mantine/core';
 import { IconAlertCircle, IconAlertTriangle } from '@tabler/icons-react';
 import { openConfirm } from '../utils/confirm-modal.js';
 import { focusReturnProps } from '../utils/focus-return.js';
 import { formatRelativeTime } from '../relative-time.js';
 import { EDITOR_ACTIONS } from '../copy.js';
 import { useSystemHealth, } from './useSystemHealth.js';
+import { ageDeletionHold, archivedBefore, archivedCutoff, deletableByAge, } from '../../branch-archive.js';
 import { escapeForLog } from '../../utils/escape-text.js';
 import { TooltipDetail } from '../components/TooltipDetail.js';
 import { DISMISS_UNPUBLISHED_ATTRIBUTE, UnpublishedAtMergeAlert } from './UnpublishedAtMergeAlert.js';
@@ -256,6 +257,7 @@ function duplicateScanSummary(health, healthyDirNames) {
         return { text: 'No duplicate content IDs found.', color: 'dimmed' };
     return { text: parts.join(' '), color: 'orange' };
 }
+const DEFAULT_CLEANUP_DAYS = 90;
 const PURGE_CONFIRM_TEXT = 'The directory is moved to a hidden trash name and kept for 30 days, then deleted. Any git work inside was never pushed and will be lost when the trash is swept.';
 export function SystemHealthPanel({ opened, onClose, returnFocusTo }) {
     const health = useSystemHealth({ isOpen: opened });
@@ -348,6 +350,55 @@ function TasksTab({ health }) {
                                 ? corruptRows.map((file) => (_jsxs(Table.Tr, { children: [_jsx(Table.Td, { children: _jsx("span", { title: file.fileName, children: truncate(file.fileName, 30) }) }), _jsxs(Table.Td, { children: [file.size, " bytes"] }), _jsx(Table.Td, { children: file.mtime }), _jsx(Table.Td, { children: _jsx(Code, { block: true, style: { maxWidth: 320, whiteSpace: 'pre-wrap' }, children: file.rawSnippet }) }), _jsx(Table.Td, { children: _jsx(Button, { variant: "light", color: "red", "data-testid": `delete-task-${file.fileName}`, onClick: () => handleDeleteClick('corrupt', file.fileName), children: "Delete" }) })] }, file.fileName)))
                                 : taskRows.map((task) => (_jsxs(Table.Tr, { children: [_jsx(Table.Td, { children: _jsx("span", { title: task.id, children: truncate(task.id, 12) }) }), _jsx(Table.Td, { children: task.action }), _jsx(Table.Td, { children: task.createdAt }), _jsx(Table.Td, { children: task.retryCount ?? 0 }), _jsx(Table.Td, { children: task.error ? (_jsx(Tooltip, { label: task.error, multiline: true, maw: 400, children: _jsx(Text, { size: "xs", style: { cursor: 'help' }, children: truncate(task.error, 50) }) })) : (_jsx(Text, { size: "xs", c: "dimmed", children: "\u2014" })) }), _jsx(Table.Td, { children: _jsxs(Group, { gap: "xs", children: [taskStatus === 'failed' && (_jsx(Button, { variant: "light", "data-testid": `retry-task-${task.id}`, onClick: () => handleRetryClick(task), children: "Retry" })), canDelete && (_jsx(Button, { variant: "light", color: "red", "data-testid": `delete-task-${task.id}`, onClick: () => handleDeleteClick(taskStatus, `${task.id}.json`), children: "Delete" }))] }) })] }, task.id))) })] }) }))] }));
 }
+/** What `lastGitSync.archivedSweep` left undone, or nothing when it finished clean. */
+const sweepTrouble = ({ failed = [], warnings = [] } = {}) => [
+    failed.length === 0
+        ? ''
+        : ` The last sweep could not delete ${failed.map((f) => f.branch).join(', ')} and tries again next sync.`,
+    ...warnings.map((warning) => ` ${endSentence(warning)}`),
+].join('');
+const dayCount = (days) => `${days} ${days === 1 ? 'day' : 'days'}`;
+/** The deployment's retention, and the admin's own delete by the same rule. */
+function ArchivedBranchesCleanup({ health }) {
+    const [days, setDays] = useState(DEFAULT_CLEANUP_DAYS);
+    const workerStatus = health.status?.workerStatus;
+    const generatedAt = health.branchHealth?.generatedAt;
+    const olderThanDays = typeof days === 'number' && Number.isInteger(days) && days > 0 ? days : null;
+    // The scan's own clock, which keeps this render pure and matches the listing it counts.
+    const cutoff = olderThanDays !== null && generatedAt
+        ? archivedCutoff(olderThanDays, Date.parse(generatedAt))
+        : null;
+    const candidates = (health.branchHealth?.entries ?? []).filter((e) => !e.isBaseBranch);
+    const branchesMatching = (matches) => cutoff === null
+        ? []
+        : candidates.flatMap((e) => (e.branch && matches(e.branch, cutoff) ? [e.branch] : []));
+    const due = branchesMatching(deletableByAge);
+    const old = branchesMatching(archivedBefore);
+    const heldFor = (hold) => old.filter((branch) => ageDeletionHold(branch) === hold).map((branch) => branch.name);
+    const notMerged = heldFor('not-merged');
+    const unpublished = heldFor('unpublished');
+    const anyDeletable = candidates.some((e) => e.branch && deletableByAge(e.branch, Number.POSITIVE_INFINITY));
+    const dueLabel = `${due.length} archived ${due.length === 1 ? 'branch' : 'branches'}`;
+    const blockedReason = olderThanDays === null
+        ? 'Enter a whole number of days.'
+        : due.length === 0
+            ? `No merged archived branches are older than ${dayCount(olderThanDays)}.${olderThanDays > 1 && anyDeletable ? ' Lower the number of days to include newer ones.' : ''}${old.length > 0 ? ' Older branches kept from this delete go one at a time, from the "Branches" drawer.' : ''}`
+            : undefined;
+    const handleDeleteClick = () => {
+        if (blockedReason || olderThanDays === null)
+            return;
+        openConfirm({
+            title: 'Delete archived branches',
+            children: (_jsxs(Stack, { gap: "xs", children: [_jsxs(Text, { size: "sm", children: ["Delete ", dueLabel, " and their comments from the editor? Their GitHub branches stay. This cannot be undone."] }), _jsx(Text, { size: "xs", "data-testid": "delete-archived-names", children: due.map((branch) => branch.name).join(', ') }), notMerged.length > 0 && (_jsxs(Text, { size: "xs", "data-testid": "delete-archived-not-merged", children: ["Kept, as they were not merged: ", notMerged.join(', '), "."] })), unpublished.length > 0 && (_jsxs(Text, { size: "xs", "data-testid": "delete-archived-unpublished", children: ["Kept, as they may hold changes missing from GitHub: ", unpublished.join(', '), "."] }))] })),
+            labels: { confirm: 'Delete branches', cancel: 'Cancel' },
+            confirmProps: { color: 'red', 'data-testid': 'confirm-delete-archived' },
+            onConfirm: () => health.deleteArchivedBranches(olderThanDays, due.map((branch) => branch.name)),
+        });
+    };
+    return (_jsxs(Stack, { gap: 4, mb: "sm", "data-testid": "archived-branches-cleanup", children: [_jsx(Text, { size: "sm", fw: 600, children: "Archived branches" }), _jsxs(Group, { align: "flex-end", gap: "xs", children: [_jsx(NumberInput, { label: "Delete merged archived branches older than", suffix: days === 1 ? ' day' : ' days', size: "xs", w: 280, min: 1, allowDecimal: false, allowNegative: false, value: days, onChange: setDays, "data-testid": "archived-days-input" }), _jsx(Tooltip, { label: blockedReason, disabled: !blockedReason, multiline: true, maw: 280, position: "top-end", children: _jsxs(Button, { size: "xs", variant: "light", color: "red", onClick: handleDeleteClick, loading: health.deletingArchivedBranches, "data-disabled": blockedReason ? true : undefined, "aria-disabled": blockedReason ? true : undefined, "data-testid": "delete-archived-button", children: ["Delete ", blockedReason ? 'archived branches' : dueLabel] }) })] }), workerStatus?.lastGitSync && (_jsxs(Text, { size: "xs", c: "dimmed", "data-testid": "archived-retention-note", children: [workerStatus.archivedBranchRetentionDays === undefined
+                        ? 'This deployment keeps archived branches until someone deletes them.'
+                        : `This deployment deletes merged branches ${dayCount(workerStatus.archivedBranchRetentionDays)} after archiving.`, sweepTrouble(workerStatus.lastGitSync?.archivedSweep)] }))] }));
+}
 function BranchesTab({ health }) {
     const { branchHealth, branchHealthLoading } = health;
     const entries = branchHealth?.entries ?? [];
@@ -399,7 +450,7 @@ function BranchesTab({ health }) {
     if (entries.length === 0) {
         return (_jsx(Text, { size: "sm", c: "dimmed", py: "md", children: "No branch directories found." }));
     }
-    return (_jsxs(Stack, { gap: "xs", children: [_jsxs(Group, { justify: "space-between", align: "center", wrap: "nowrap", children: [_jsx(Text, { size: "xs", c: duplicateSummary.color, "data-testid": "duplicate-id-summary", children: duplicateSummary.text }), _jsx(Button, { size: "compact-xs", variant: "subtle", loading: health.duplicateIdScanLoading, onClick: () => health.checkDuplicateIds(), children: "Check again" })] }), _jsx(Table.ScrollContainer, { minWidth: 700, children: _jsxs(Table, { children: [_jsx(Table.Thead, { children: _jsxs(Table.Tr, { children: [_jsx(Table.Th, { children: "Name" }), _jsx(Table.Th, { children: "Status" }), _jsx(Table.Th, { children: "PR" }), _jsx(Table.Th, { children: "Sync" }), _jsx(Table.Th, { children: "Warnings" }), _jsx(Table.Th, { children: "Updated" }), _jsx(Table.Th, { children: "Actions" })] }) }), _jsx(Table.Tbody, { children: entries.map((entry) => (_jsx(BranchHealthRow, { entry: entry, baseWarning: entry.isBaseBranch ? baseWarning : null, duplicateIdScan: health.duplicateIdScan
+    return (_jsxs(Stack, { gap: "xs", children: [_jsx(ArchivedBranchesCleanup, { health: health }), _jsxs(Group, { justify: "space-between", align: "center", wrap: "nowrap", children: [_jsx(Text, { size: "xs", c: duplicateSummary.color, "data-testid": "duplicate-id-summary", children: duplicateSummary.text }), _jsx(Button, { size: "compact-xs", variant: "subtle", loading: health.duplicateIdScanLoading, onClick: () => health.checkDuplicateIds(), children: "Check again" })] }), _jsx(Table.ScrollContainer, { minWidth: 700, children: _jsxs(Table, { children: [_jsx(Table.Thead, { children: _jsxs(Table.Tr, { children: [_jsx(Table.Th, { children: "Name" }), _jsx(Table.Th, { children: "Status" }), _jsx(Table.Th, { children: "PR" }), _jsx(Table.Th, { children: "Sync" }), _jsx(Table.Th, { children: "Warnings" }), _jsx(Table.Th, { children: "Updated" }), _jsx(Table.Th, { children: "Actions" })] }) }), _jsx(Table.Tbody, { children: entries.map((entry) => (_jsx(BranchHealthRow, { entry: entry, baseWarning: entry.isBaseBranch ? baseWarning : null, duplicateIdScan: health.duplicateIdScan
                                     ? (health.duplicateIdScan.byDir[entry.dirName] ?? null)
                                     : undefined, onMarkMerged: handleMarkMergedClick, onRepair: handleRepairClick, onPurge: handlePurgeClick, onDuplicateIds: handleDuplicateIdsClick }, entry.dirName))) })] }) })] }));
 }
@@ -419,7 +470,7 @@ const firstFailed = (iso) => {
 function BranchHealthRow({ entry, baseWarning, duplicateIdScan, onMarkMerged, onRepair, onPurge, onDuplicateIds, }) {
     if (entry.kind === 'healthy' && entry.branch) {
         const b = entry.branch;
-        // The worker looks at every branch but 'archived' (already merged): one in review is not
+        // The worker looks at every branch but 'archived' (finished): one in review is not
         // rebased, but commits from GitHub are still brought into it. An exclusion, not a list of
         // statuses, so a status added later still shows its failures by default.
         const showRebaseFailure = b.status !== 'archived' && !!b.rebaseFailure;
@@ -429,7 +480,9 @@ function BranchHealthRow({ entry, baseWarning, duplicateIdScan, onMarkMerged, on
             : !inReview
                 ? b.unpublishedAtMerge
                     ? { kind: 'unpublished-at-merge' }
-                    : undefined
+                    : b.status === 'archived' && b.rewrittenOnGitHub !== undefined
+                        ? { kind: 'rewritten-at-merge', commit: b.rewrittenOnGitHub }
+                        : undefined
                 : b.submitUnfinished
                     ? {
                         kind: 'submit-unfinished',
@@ -437,7 +490,9 @@ function BranchHealthRow({ entry, baseWarning, duplicateIdScan, onMarkMerged, on
                         notQueued: b.submitNotQueued,
                     }
                     : b.pullRequestHold;
-        const canMarkMerged = (b.status === 'submitted' || b.status === 'approved') && !!b.pullRequestNumber;
+        const canMarkMerged = (b.status === 'submitted' || b.status === 'approved') &&
+            !!b.pullRequestNumber &&
+            b.pullRequestState !== 'closed';
         return (_jsxs(Table.Tr, { children: [_jsx(Table.Td, { children: _jsxs(Group, { gap: 4, wrap: "nowrap", children: [_jsx(Text, { size: "sm", children: entry.dirName }), entry.isBaseBranch && (_jsx(Badge, { size: "xs", color: "gray", variant: "outline", children: "Base" }))] }) }), _jsx(Table.Td, { children: _jsx(Badge, { color: branchStatusPresentation(b.status)?.color ?? 'neutral', variant: "light", children: branchStatusPresentation(b.status)?.label }) }), _jsx(Table.Td, { children: b.pullRequestNumber ? (_jsxs(Text, { size: "xs", c: "blue", component: "a", href: b.pullRequestUrl, target: "_blank", rel: "noopener noreferrer", style: { textDecoration: 'underline' }, children: ["PR #", b.pullRequestNumber, b.pullRequestState ? ` (${b.pullRequestState})` : ''] })) : (_jsx(Text, { size: "xs", c: "dimmed", children: "\u2014" })) }), _jsx(Table.Td, { children: b.syncStatus === 'sync-failed' ? (_jsx(TooltipDetail, { preLine: true, detail: syncFailedDetail(b.syncFailureReason, hold?.kind !== 'rewritten' &&
                             b.status !== 'archived' &&
                             !(b.submitUnfinished && b.submitNotQueued)), children: _jsx(Badge, { color: "red", variant: "light", children: "Sync failed" }) })) : b.syncStatus === 'pending-sync' ? (_jsx(Badge, { color: "gray", variant: "light", children: "Pending sync" })) : null }), _jsx(Table.Td, { children: _jsxs(Group, { gap: 6, children: [!!b.conflictFiles?.length && (_jsxs(Badge, { color: "orange", variant: "light", children: [b.conflictFiles.length, " conflict", b.conflictFiles.length === 1 ? '' : 's'] })), hold && (_jsx(TooltipDetail, { detail: branchHoldMessage(hold, {

package/dist/editor/admin/useSystemHealth.d.ts

@@ -51,6 +51,9 @@ export interface UseSystemHealthReturn {
     purgeDir: (dirName: string) => Promise<void>;
     repairDir: (dirName: string) => Promise<void>;
     markMerged: (branchName: string) => Promise<void>;
+    /** Deletes those of `branches` still past `olderThanDays`, then says what it could not. */
+    deleteArchivedBranches: (olderThanDays: number, branches: string[]) => Promise<void>;
+    deletingArchivedBranches: boolean;
     /** Stops listing a branch merged with an unfinished submit, a warning that doesn't come back. */
     dismissUnpublished: (dirName: string) => Promise<void>;
 }

package/dist/editor/admin/useSystemHealth.js

@@ -16,7 +16,16 @@ import { useSWRConfig } from 'swr';
 import { notifications } from '@mantine/notifications';
 import { useApiClient } from '../context/index.js';
 import { BRANCHES_KEY } from '../hooks/useBranchesData.js';
+import { isGatewayFailure, isUnanswered, UnansweredError } from '../unanswered.js';
 const POLL_INTERVAL_MS = 30_000;
+const EMPTY_DELETE = {
+    deleted: [],
+    skipped: { notMerged: [], unpublished: [] },
+    failed: [],
+    remaining: 0,
+    warnings: [],
+};
+const countBranches = (count) => `${count} archived ${count === 1 ? 'branch' : 'branches'}`;
 /**
  * Crash-loop rider window: a worker that fatally exits and restarts
  * repeatedly can flap between 'absent' and 'alive' and never sit still long
@@ -38,6 +47,7 @@ export function useSystemHealth(options) {
     const [duplicateIdScan, setDuplicateIdScan] = useState(null);
     const [duplicateIdScanLoading, setDuplicateIdScanLoading] = useState(false);
     const [duplicateIdScanError, setDuplicateIdScanError] = useState(null);
+    const [deletingArchivedBranches, setDeletingArchivedBranches] = useState(false);
     const [error, setError] = useState(null);
     // refresh() has no status argument, so it needs the CURRENT taskStatus
     // without depending on it (that would tear down/rebuild the poll interval
@@ -266,6 +276,53 @@ export function useSystemHealth(options) {
             notifications.show({ message, color: 'red' });
         }
     }, [apiClient, refresh]);
+    const deleteArchivedBranches = useCallback(async (olderThanDays, branches) => {
+        setDeletingArchivedBranches(true);
+        try {
+            const result = await apiClient.admin.deleteArchivedBranches({ olderThanDays, branches });
+            if (isGatewayFailure(result))
+                throw new UnansweredError();
+            if (!result.ok)
+                throw new Error(result.error || 'Failed to delete archived branches');
+            const { deleted, skipped, failed, remaining, warnings } = result.data ?? EMPTY_DELETE;
+            const left = [
+                failed.length > 0
+                    ? `${countBranches(failed.length)} not deleted: busy, or changed since listed`
+                    : '',
+                remaining > 0 ? `${countBranches(remaining)} not reached, run this again` : '',
+                skipped.notMerged.length > 0
+                    ? `${countBranches(skipped.notMerged.length)} kept: not merged`
+                    : '',
+                skipped.unpublished.length > 0
+                    ? `${countBranches(skipped.unpublished.length)} kept: may hold unpublished changes`
+                    : '',
+                ...warnings,
+            ].filter(Boolean);
+            const message = `Deleted ${countBranches(deleted.length)}`;
+            notifications.show(left.length > 0
+                ? { message: `${message}. ${left.join('. ')}.`, color: 'yellow', autoClose: false }
+                : { message, color: 'green' });
+            await mutate(BRANCHES_KEY);
+            await refresh();
+        }
+        catch (err) {
+            if (isUnanswered(err)) {
+                notifications.show({
+                    message: 'Deleting archived branches may have gone through even though the server didn\'t answer. Check the "Branches" tab.',
+                    color: 'yellow',
+                    autoClose: false,
+                });
+                await mutate(BRANCHES_KEY);
+                await refresh();
+                return;
+            }
+            const message = err instanceof Error ? err.message : 'Failed to delete archived branches';
+            notifications.show({ message, color: 'red', autoClose: false });
+        }
+        finally {
+            setDeletingArchivedBranches(false);
+        }
+    }, [apiClient, mutate, refresh]);
     return {
         status,
         statusLoading,
@@ -288,6 +345,8 @@ export function useSystemHealth(options) {
         purgeDir,
         repairDir,
         markMerged,
+        deleteArchivedBranches,
+        deletingArchivedBranches,
         dismissUnpublished,
     };
 }

package/dist/editor/branch-status.js

@@ -77,6 +77,15 @@ export function branchHoldMessage(hold, viewer) {
                     : '';
             return `${stuck} ${retry}${instead}.`;
         }
+        case 'rewritten-at-merge': {
+            const commit = hold.commit
+                ? ` GitHub no longer contains commit ${escapeForLog(hold.commit)}.`
+                : '';
+            const stuck = `This branch was changed on GitHub before it was archived, so some changes here may be missing from GitHub.${commit}`;
+            return viewer.isAdmin
+                ? `${stuck} Check them before deleting the branch.`
+                : `${stuck} Ask an admin to check it.`;
+        }
         case 'unpublished-at-merge': {
             const stuck = 'This pull request merged before the last submit finished, so some changes may not be in the merge.';
             if (viewer.inSystemHealth)

package/dist/editor/copy.d.ts

@@ -14,6 +14,7 @@ export declare const EDITOR_ACTIONS: {
     readonly requestChanges: "Request changes";
     readonly switchBranch: "Switch branch";
     readonly newBranch: "New branch";
+    readonly archiveBranch: "Archive branch";
     readonly remove: "Remove";
     readonly restore: "Restore";
     readonly clear: "Clear";
@@ -34,5 +35,7 @@ export declare const rewrittenSubmitReason: (isAdmin: boolean) => string;
  * says how to finish the submit, where it can be retried at all.
  */
 export declare const UNFINISHED_SUBMIT_APPROVE_REASON = "The last submit didn't finish, so this branch can't be approved yet. Use \"Request changes\" to send it back to its editor.";
+/** Why only an admin may delete a branch that may hold commits nothing else has. */
+export declare const DELETE_NEEDS_ADMIN_REASON = "This branch may hold changes that are missing from GitHub. Ask an admin to check it before deleting it.";
 /** Why Approve and Request changes can't act: the pull request they act on is gone. */
 export declare const CLOSED_PULL_REQUEST_REASON = "The pull request was closed on GitHub. Use \"Withdraw from review\", then submit it again to open a new one.";

package/dist/editor/copy.js

@@ -14,6 +14,7 @@ export const EDITOR_ACTIONS = {
     requestChanges: 'Request changes',
     switchBranch: 'Switch branch',
     newBranch: 'New branch',
+    archiveBranch: 'Archive branch',
     remove: 'Remove',
     restore: 'Restore',
     clear: 'Clear',
@@ -36,5 +37,7 @@ export const rewrittenSubmitReason = (isAdmin) => isAdmin
  * says how to finish the submit, where it can be retried at all.
  */
 export const UNFINISHED_SUBMIT_APPROVE_REASON = 'The last submit didn\'t finish, so this branch can\'t be approved yet. Use "Request changes" to send it back to its editor.';
+/** Why only an admin may delete a branch that may hold commits nothing else has. */
+export const DELETE_NEEDS_ADMIN_REASON = 'This branch may hold changes that are missing from GitHub. Ask an admin to check it before deleting it.';
 /** Why Approve and Request changes can't act: the pull request they act on is gone. */
 export const CLOSED_PULL_REQUEST_REASON = 'The pull request was closed on GitHub. Use "Withdraw from review", then submit it again to open a new one.';

package/dist/editor/hooks/useBranchManager.d.ts

@@ -28,8 +28,11 @@ export declare const CREATED_BRANCH_GRACE_MS = 120000;
 interface BranchSummary {
     name: string;
     shortName?: string;
+    title?: string;
     status: string;
     createdBy?: string;
+    /** The creator's display name, when the listing carried it. */
+    ownerName?: string;
     updatedAt?: string;
     access: {
         users: string[] | undefined;
@@ -126,6 +129,8 @@ export interface UseBranchManagerReturn {
     /** Confirms first, taking an optional note; focus returns as for `handleApprove`. */
     handleRequestChanges: (branchName: string, returnFocusTo?: () => HTMLElement | null) => Promise<void>;
     handleDelete: (branchName: string) => Promise<void>;
+    /** Admin only: confirms first, then archives a branch whose pull request closed unmerged. */
+    handleArchive: (branchName: string) => Promise<void>;
     handleReloadBranchData: () => Promise<void>;
     loadBranches: () => Promise<void>;
 }

package/dist/editor/hooks/useBranchManager.js

@@ -201,7 +201,7 @@ const showDeleteConfirmation = (branchName, pr, mayHoldUnpublished, onConfirm, o
             : undefined,
         'Discard any unsaved or unmerged changes',
         mayHoldUnpublished
-            ? 'Remove the only copy of any changes that never reached GitHub, and the warning about them'
+            ? 'Remove the only copy of any changes missing from GitHub, and the warning about them'
             : undefined,
     ].filter((b) => b !== undefined);
     openConfirm({
@@ -217,6 +217,16 @@ const showDeleteConfirmation = (branchName, pr, mayHoldUnpublished, onConfirm, o
         ...confirmModalHandlers(onConfirm, onDismiss),
     });
 };
+/** Archiving is a one-way status change on a branch whose review is over. */
+const showArchiveConfirmation = (branchName, inReview, onConfirm, onDismiss) => {
+    openConfirm({
+        title: EDITOR_ACTIONS.archiveBranch,
+        children: (_jsx(Text, { size: "sm", style: { whiteSpace: 'pre-line' }, children: `Archive “${branchName}”?\n\nIts pull request was closed without merging. This will:\n• Make the branch read-only and move it to “Archived”\n• Keep it marked as not merged\n\nAn archived branch can't go back to editing. This one stays until someone deletes it: automatic and bulk deletes only take merged branches.${inReview ? ` To keep working on it, use “${EDITOR_ACTIONS.withdrawFromReview}” instead.` : ''}` })),
+        labels: { confirm: EDITOR_ACTIONS.archiveBranch, cancel: 'Cancel' },
+        confirmProps: { color: 'orange', 'data-testid': 'confirm-archive-branch' },
+        ...confirmModalHandlers(onConfirm, onDismiss),
+    });
+};
 /**
  * How long a branch this session created stays overlaid on listings. Each warm
  * server container caches the shared filesystem separately, so for its
@@ -381,8 +391,10 @@ export function useBranchManager(options) {
             return {
                 name: b.name,
                 shortName: b.shortName,
+                title: b.title,
                 status: b.status,
                 createdBy: b.createdBy,
+                ownerName: branchesData?.ownerNames?.[b.createdBy],
                 updatedAt: b.updatedAt,
                 access: {
                     users: b.access.allowedUsers,
@@ -423,7 +435,7 @@ export function useBranchManager(options) {
                 submitBlocked: b.submitBlocked ?? true,
             };
         });
-    }, [branches, currentBranchName, options.comments]);
+    }, [branches, branchesData?.ownerNames, currentBranchName, options.comments]);
     // Explicit reload: always issues a fresh, independent fetch (raw call, not
     // SWR's `mutate()` revalidate path) so callers requesting a reload right
     // after mount aren't coalesced against the still-in-flight automatic load
@@ -730,6 +742,45 @@ export function useBranchManager(options) {
             }, () => resolve(), returnFocusTo);
         }));
     };
+    const handleArchive = (requested) => {
+        const branchNameToArchive = listedName(requested);
+        return singleFlight('archive', branchNameToArchive, () => new Promise((resolve, reject) => {
+            const status = latest.current.branches.find((b) => b.name === branchNameToArchive)?.status;
+            showArchiveConfirmation(shownName(branchNameToArchive), status === 'submitted' || status === 'approved', async () => {
+                options.setBusy(true);
+                try {
+                    const result = await apiClient.workflow.archive({
+                        branch: sendName(branchNameToArchive),
+                    });
+                    if (!result.ok)
+                        throw actionError(result, 'Failed to archive branch');
+                    notifications.show({ message: 'Branch archived', color: 'blue' });
+                    forgetCreatedBranch(branchNameToArchive);
+                    await loadBranches();
+                    resolve();
+                }
+                catch (err) {
+                    if (err instanceof RefusedError && err.status === 409) {
+                        // Nothing is lost, and the list says what changed.
+                        notifications.show({
+                            message: err.message,
+                            color: 'yellow',
+                            autoClose: false,
+                            withCloseButton: true,
+                        });
+                        await reloadBranches();
+                        resolve();
+                        return;
+                    }
+                    await reportActionFailure(err, 'Failed to archive branch', EDITOR_ACTIONS.archiveBranch);
+                    reject(err);
+                }
+                finally {
+                    options.setBusy(false);
+                }
+            }, () => resolve());
+        }));
+    };
     const handleApprove = (requested, returnFocusTo) => {
         const branchNameToApprove = listedName(requested);
         return singleFlight('approve', branchNameToApprove, () => new Promise((resolve, reject) => {
@@ -838,8 +889,7 @@ export function useBranchManager(options) {
         const branchNameToDelete = listedName(requested);
         const listedBefore = latest.current.branches;
         return singleFlight('delete', branchNameToDelete, () => new Promise((resolve) => {
-            showDeleteConfirmation(shownName(branchNameToDelete), pullRequestOf(branchNameToDelete), listedBefore.find((b) => b.name === branchNameToDelete)?.hold?.kind ===
-                'unpublished-at-merge', async () => {
+            showDeleteConfirmation(shownName(branchNameToDelete), pullRequestOf(branchNameToDelete), ['unpublished-at-merge', 'rewritten-at-merge'].includes(listedBefore.find((b) => b.name === branchNameToDelete)?.hold?.kind ?? ''), async () => {
                 options.setBusy(true);
                 try {
                     const result = await apiClient.branches.delete({
@@ -960,6 +1010,7 @@ export function useBranchManager(options) {
         handleApprove,
         handleRequestChanges,
         handleDelete,
+        handleArchive,
         handleReloadBranchData,
         loadBranches,
     };

package/dist/editor/hooks/useBranchesData.d.ts

@@ -19,6 +19,8 @@ export declare const BRANCHES_KEY = "canopy:branches";
 export interface BranchesData {
     branches: BranchListItem[];
     defaultBranch?: string;
+    /** Display names of the listed branches' creators, by user id. */
+    ownerNames?: Readonly<Record<string, string>>;
     /**
      * Client clock when this listing arrived. It makes listings fetched at
      * different moments distinct `data` values even when their branches match,

package/dist/editor/hooks/useBranchesData.js

@@ -33,10 +33,12 @@ export async function fetchBranches(apiClient, swr) {
     if (!result.ok) {
         throw new Error(result.error ?? `Failed to load branches: ${result.status}`);
     }
-    await seedUserProfiles(swr, result.data?.users ?? []);
+    const users = result.data?.users ?? [];
+    await seedUserProfiles(swr, users);
     return {
         branches: result.data?.branches ?? [],
         defaultBranch: result.data?.defaultBranch,
+        ownerNames: Object.fromEntries(users.map((user) => [user.id, user.name])),
         receivedAt: Date.now(),
     };
 }

package/dist/types.d.ts

@@ -12,6 +12,22 @@ export type CanopyGroupId = string;
  * semantics (worker rebase skip list, a set/unset endpoint, UI).
  */
 export type BranchStatus = 'editing' | 'submitted' | 'approved' | 'archived';
+/** One cycle of the worker's retention sweep (worker/archived-sweep.ts). */
+export interface ArchivedSweepReport {
+    /** Full names of the branches deleted. */
+    deleted: string[];
+    /** Due, but another process held the branch's provisioning lock; retried next cycle. */
+    skippedLocked: string[];
+    /** [REDACT] Served to the admin panel, so `error` is sanitized. */
+    failed: {
+        branch: string;
+        error: string;
+    }[];
+    /** Due, beyond this cycle's cap; the next cycle takes the oldest of them. */
+    deferred: number;
+    /** Deleted, with something left behind, sanitized as `failed` is ([REDACT]). */
+    warnings: string[];
+}
 export type SyncStatus = 'synced' | 'pending-sync' | 'sync-failed';
 export type ConflictStatus = 'clean' | 'conflicts-detected';
 export type PullRequestState = 'open' | 'closed' | 'merged';
@@ -57,6 +73,14 @@ export type BranchHold = PullRequestHold | {
 /** Admins see what to do in System health. */
  | {
     kind: 'unpublished-at-merge';
+}
+/**
+ * An archived branch rewritten on GitHub, which may hold commits GitHub dropped. `commit`, the
+ * one GitHub no longer contains, is for System health; the API leaves it out.
+ */
+ | {
+    kind: 'rewritten-at-merge';
+    commit?: string;
 };
 export interface BranchMetadata {
     name: string;
@@ -106,6 +130,11 @@ export interface BranchMetadata {
      * (worker auto-poll or markAsMerged). Absent for branches archived any other way.
      */
     mergedAt?: string;
+    /**
+     * When the branch was archived, merged or not: the clock retention counts from. A branch
+     * archived before this field existed has only `mergedAt` (branch-archive.ts).
+     */
+    archivedAt?: string;
     /**
      * Set by the worker when a rebase cycle fails for this branch; cleared on
      * the next successful cycle (and on submit). firstAt survives repeated
@@ -292,6 +321,8 @@ export interface WorkerStatusReport {
     updatedAt: string;
     lastTaskCycleAt?: string;
     lastGitSyncAt?: string;
+    /** The deployment's `archivedBranchRetentionDays`; absent when retention is off. */
+    archivedBranchRetentionDays?: number;
     lastGitSyncError?: {
         message: string;
         at: string;
@@ -314,6 +345,8 @@ export interface WorkerStatusReport {
         }[];
         /** Optional for the same reason as `tracked` below. */
         baseRefresh?: BaseRefreshReport;
+        /** The retention sweep's work this cycle; absent when it found nothing to do. */
+        archivedSweep?: ArchivedSweepReport;
         /**
          * Outcome of reconciling remote.git's `refs/heads/*` against GitHub's fetched
          * tips, never moving a head the worker finds editor work in (worker/git-sync.ts's

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const CANOPYCMS_VERSION = "0.9.0";
+export declare const CANOPYCMS_VERSION = "0.10.0";

package/dist/version.js

@@ -1,3 +1,3 @@
 // Generated by scripts/bump-version.mjs, its only writer. The package builds with plain
 // tsc (rootDir: src), so src/ cannot import ../package.json; version.test.ts keeps the two equal.
-export const CANOPYCMS_VERSION = '0.9.0';
+export const CANOPYCMS_VERSION = '0.10.0';

package/dist/worker/archived-sweep.d.ts

@@ -0,0 +1,23 @@
+import type { ArchivedSweepReport } from '../types.js';
+import type { WorkerContext } from './worker-context.js';
+export type ArchivedSweepContext = Pick<WorkerContext, 'archivedBranchRetentionDays' | 'contentBranchesPath' | 'ensureSettingsBranch' | 'isDraining' | 'sanitizedBaseBranch'>;
+/**
+ * The most branches one cycle deletes, oldest first: turning retention on over a long backlog must
+ * not stall the sync loop. The rest wait for the next cycle.
+ * @internal Exported for tests.
+ */
+export declare const MAX_ARCHIVED_SWEEP_PER_CYCLE = 25;
+/**
+ * Delete merged, archived branches past `archivedBranchRetentionDays`, oldest first, through the
+ * one delete path (branch-delete.ts). Off unless the deployment set that.
+ *
+ * Each branch is held by its provisioning lock, zero-retry as everywhere in the sync loop, and the
+ * selection is decided again under the lock the delete takes, from a fresh read.
+ *
+ * Takes the editor's copy only: `remoteCopies` in branch-delete.ts says why, and reconcile prunes
+ * a head no workspace holds once GitHub drops it (stale-mirror.ts).
+ *
+ * Never throws, and one branch's failure costs only that branch, which the next cycle retries. A
+ * kill past the rename leaves a `.deleting-*` directory `sweepProvisioningLeftovers` clears.
+ */
+export declare function sweepArchivedBranches(ctx: ArchivedSweepContext, now?: number): Promise<ArchivedSweepReport | undefined>;