hanna/fabrica

feat: archive repositories (read-only) with an archived badge

a6f131a · hanna committed on 2026-07-25

Add repo archiving: store set_archived, a `repo archive`/`repo unarchive`
CLI, an Archive section on the repo Settings page, and an archived badge in
the repo header and listings. SSH refuses pushes (receive-pack) to an
archived repo. Extract the collaborators settings block into a helper to keep
the settings view within the line limit.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Signed by hannaSSH key fingerprint: SHA256:4g9cWhkAAw8gwqhJUcVbSnGEvdGwklW+1Aa/fMUu59k

assets/base.css +4 −0

crates/cli/src/repo_cmd.rs +38 −0

crates/ssh/src/server.rs +5 −0

crates/store/src/repos.rs +20 −0

crates/web/src/lib.rs +1 −0

crates/web/src/repo.rs +98 −19

   color: var(--fb-accent);
   border-color: var(--fb-accent);
+}
+.badge-archived {
+  color: var(--fb-warning);
+  border-color: var(--fb-warning);
+}
 /* Inline search row: input grows, button sits to its right with margin. */
 .search-row {

         #[command(subcommand)]
         command: CollaboratorCommand,
     },
+    /// Archive a repository (makes it read-only).
+    Archive {
+        /// The owning user.
+        user: String,
+        /// The repo name (group path included).
+        name: String,
+    },
+    /// Unarchive a repository.
+    Unarchive {
+        /// The owning user.
+        user: String,
+        /// The repo name (group path included).
+        name: String,
+    },
     /// Print the resolved on-disk directory of a repository.
     Path {
         /// The owning user.
                 block_on(collab_list(config_path, user, name, json))
+            }
         },
+        RepoCommand::Archive { user, name } => {
+            block_on(set_archived(config_path, user, name, true))
+        }
+        RepoCommand::Unarchive { user, name } => {
+            block_on(set_archived(config_path, user, name, false))
+        }
         RepoCommand::Path { user, name } => block_on(path(config_path, user, name)),
+    }
+}
+async fn set_archived(
+    config_path: Option<&Path>,
+    user: &str,
+    name: &str,
+    archived: bool,
+) -> anyhow::Result<ExitCode> {
+    let (_config, store) = open_store(config_path).await?;
+    let owner_id = require_user_id(&store, user).await?;
+    let repo = require_repo(&store, &owner_id, name, user).await?;
+    store.set_archived(&repo.id, archived).await?;
+    println!(
+        "{user}/{} is now {}",
+        repo.path,
+        if archived { "archived" } else { "active" }
+    );
+    Ok(ExitCode::SUCCESS)
+}
 /// Look up a user's id by name, or error cleanly.
 async fn require_user_id(store: &Store, name: &str) -> anyhow::Result<String> {
     store

             return Err(not_found());
         };
+        // Archived repositories are read-only: refuse any push.
+        if matches!(service, git::pack::Service::ReceivePack) && repo.archived_at.is_some() {
+            return Err("This repository is archived and is read-only.".to_string());
+        }
         let collaborator = self
             .shared
             .store

         Ok(updated > 0)
+    }
+    /// Archive or unarchive a repository. Archiving stamps `archived_at`;
+    /// unarchiving clears it. Returns `true` if the row existed and was updated.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`StoreError::Query`] on a database failure.
+    pub async fn set_archived(&self, repo_id: &str, archived: bool) -> Result<bool, StoreError> {
+        let now = now_ms();
+        let archived_at = archived.then_some(now);
+        let updated =
+            sqlx::query("UPDATE repos SET archived_at = $1, updated_at = $2 WHERE id = $3")
+                .bind(archived_at)
+                .bind(now)
+                .bind(repo_id)
+                .execute(&self.pool)
+                .await?
+                .rows_affected();
+        Ok(updated > 0)
+    }
     /// Record that a repository was just pushed to: stamp `pushed_at` and refresh
     /// `size_bytes`. Called by `fabrica hook post-receive`.
     ///

         // Repo administration (owner/admin only; enforced in the handlers). A
         // fixed prefix so it never collides with the `/{owner}/{*rest}` catch-all.
         .route("/repo-settings/{id}/general", post(repo::settings_general))
+        .route("/repo-settings/{id}/archive", post(repo::settings_archive))
         .route("/repo-settings/{id}/delete", post(repo::settings_delete))
         .route(
             "/repo-settings/{id}/collaborators",

             option value=(value.as_str()) selected[vis == value] { (label) }
+        }
     };
-    let perm_option = |value: &str, label: &str| {
-        html! { option value=(value) { (label) } }
-    };
     let body = html! {
         (repo_header(state, &ctx, Tab::Settings, &ctx.repo.default_branch, &branches))
         section class="listing" {
+                }
+            }
+        }
+        (collaborators_section(id, &chrome.csrf, &collaborators))
+        section class="listing" {
+            h2 { "Archive" }
+            div class="card" {
+                @if ctx.repo.archived_at.is_some() {
+                    p class="muted" { "This repository is archived (read-only). Unarchiving restores pushing." }
+                    form method="post" action=(format!("/repo-settings/{id}/archive")) {
+                        input type="hidden" name="_csrf" value=(chrome.csrf);
+                        input type="hidden" name="archived" value="false";
+                        button class="btn btn-primary" type="submit" { "Unarchive repository" }
+                    }
+                } @else {
+                    p class="muted" { "Archiving makes the repository read-only; pushes are refused until it is unarchived." }
+                    form method="post" action=(format!("/repo-settings/{id}/archive")) {
+                        input type="hidden" name="_csrf" value=(chrome.csrf);
+                        input type="hidden" name="archived" value="true";
+                        button class="btn" type="submit" { "Archive repository" }
+                    }
+                }
+            }
+        }
+        section class="listing" {
+            h2 { "Danger zone" }
+            div class="card danger-zone" {
+                p { strong { "Delete this repository." } " This permanently removes it from fabrica; the on-disk copy is moved to trash." }
+                form method="post" action=(format!("/repo-settings/{id}/delete")) {
+                    input type="hidden" name="_csrf" value=(chrome.csrf);
+                    button class="btn btn-danger" type="submit" { "Delete repository" }
+                }
+            }
+        }
+    };
+    let title = format!("{}/{}: settings", ctx.owner.username, ctx.repo.path);
+    Ok((jar, page(&chrome, &title, body)).into_response())
+}
+/// The Collaborators section of the repo settings page: the current list with
+/// remove buttons, and the add form.
+fn collaborators_section(id: &str, csrf: &str, collaborators: &[store::Collaborator]) -> Markup {
+    let perm_option = |value: &str, label: &str| html! { option value=(value) { (label) } };
+    html! {
         section class="listing" {
             h2 { "Collaborators" }
             div class="card" {
                     p class="muted" { "No collaborators yet." }
                 } @else {
                     ul class="entry-list collab-list" {
-                        @for c in &collaborators {
+                        @for c in collaborators {
                             li class="entry-row" {
                                 div class="entry-row-body" {
                                     a class="entry-row-title" href={ "/" (c.username) } { (c.username) }
                                 div class="entry-row-actions" {
                                     form method="post"
                                          action=(format!("/repo-settings/{id}/collaborators/remove")) {
-                                        input type="hidden" name="_csrf" value=(chrome.csrf);
+                                        input type="hidden" name="_csrf" value=(csrf);
                                         input type="hidden" name="user_id" value=(c.user_id);
                                         button class="btn btn-danger" type="submit" { "Remove" }
+                                    }
+                }
                 form class="collab-add" method="post"
                      action=(format!("/repo-settings/{id}/collaborators")) {
-                    input type="hidden" name="_csrf" value=(chrome.csrf);
+                    input type="hidden" name="_csrf" value=(csrf);
                     input type="text" name="username" placeholder="Username" aria-label="Username" required;
                     select name="permission" aria-label="Permission" {
                         (perm_option("read", "Read"))
+                }
+            }
+        }
-        section class="listing" {
+    }
-            h2 { "Danger zone" }
-            div class="card danger-zone" {
-                p { strong { "Delete this repository." } " This permanently removes it from fabrica; the on-disk copy is moved to trash." }
-                form method="post" action=(format!("/repo-settings/{id}/delete")) {
-                    input type="hidden" name="_csrf" value=(chrome.csrf);
-                    button class="btn btn-danger" type="submit" { "Delete repository" }
-                }
-            }
-        }
-    };
-    let title = format!("{}/{}: settings", ctx.owner.username, ctx.repo.path);
-    Ok((jar, page(&chrome, &title, body)).into_response())
+}
 /// Resolve a repo by id and require the viewer to have `Admin` access, else a
+    }
+}
+/// The archive/unarchive form.
+#[derive(Debug, Deserialize)]
+pub struct RepoArchiveForm {
+    /// Desired archived state (`true` to archive, `false` to unarchive).
+    #[serde(default)]
+    archived: String,
+    /// CSRF token.
+    #[serde(rename = "_csrf")]
+    csrf: String,
+}
+/// `POST /repo-settings/{id}/archive` — archive or unarchive the repo.
+pub async fn settings_archive(
+    State(state): State<AppState>,
+    MaybeUser(viewer): MaybeUser,
+    jar: CookieJar,
+    headers: HeaderMap,
+    Path(id): Path<String>,
+    Form(form): Form<RepoArchiveForm>,
+) -> Response {
+    if verify_csrf(&jar, &headers, Some(&form.csrf)).is_err() {
+        return AppError::Forbidden.into_response();
+    }
+    let result = async {
+        let repo = require_admin_repo(&state, viewer.as_ref(), &id).await?;
+        state
+            .store
+            .set_archived(&repo.id, form.archived == "true")
+            .await?;
+        Ok::<String, AppError>(repo_settings_url(&state, &repo).await)
+    }
+    .await;
+    match result {
+        Ok(dest) => Redirect::to(&dest).into_response(),
+        Err(err) => err.into_response(),
+    }
+}
 /// The `/-/settings` URL for a repo, resolving the owner username.
 async fn repo_settings_url(state: &AppState, repo: &Repo) -> String {
     let owner = state
     /// When the repo was last pushed to (falling back to its last metadata
     /// change), for the "Updated …" subtitle.
     pub(crate) updated: i64,
+    /// Whether the repo is archived (shows an archived badge).
+    pub(crate) archived: bool,
     /// Optional one-line description, shown under the name when present.
     pub(crate) description: Option<String>,
+}
             visibility: repo.visibility,
             default_branch: repo.default_branch.clone(),
             updated: repo.pushed_at.unwrap_or(repo.updated_at),
+            archived: repo.archived_at.is_some(),
             description: repo.description.clone(),
+        }
+    }
             visibility: repo.visibility,
             default_branch: repo.default_branch.clone(),
             updated: repo.pushed_at.unwrap_or(repo.updated_at),
+            archived: repo.archived_at.is_some(),
             description: repo.description.clone(),
+        }
+    }
+    }
+}
+/// An "archived" badge when the repo is archived, else nothing.
+fn archived_badge(archived: bool) -> Markup {
+    html! {
+        @if archived {
+            span class="badge badge-archived" { "archived" }
+        }
+    }
+}
 /// Render a titled card of repository rows in the reference listing style: a
 /// card headed by `title`, one bordered row per repo with a bold name and a
 /// muted `visibility · default: branch` subtitle.
                                 span class="repo-row-name" {
                                     (icon(Icon::Box)) span { (e.label) }
                                     (visibility_badge(e.visibility))
+                                    (archived_badge(e.archived))
+                                }
                                 @if let Some(desc) = &e.description {
                                     span class="repo-row-desc muted" { (desc) }
                 span class="slug-sep" { "/" }
                 a href=(base) { (ctx.repo.name) }
                 (visibility_badge(ctx.repo.visibility))
+                (archived_badge(ctx.repo.archived_at.is_some()))
+            }
             @if let Some(desc) = &ctx.repo.description { p class="muted" { (desc) } }
             div class="repo-nav" {