hanna/fabrica

feat(web): mirror settings and Migrate-from-Git UI

1d9ee28 · hanna committed on 2026-07-26

- Repo settings gains a "Mirror settings" section: list configured
  mirrors with status/last-sync/errors, add a push mirror (remote URL,
  branch filter, credentials, sync-on-push, interval), and Sync-now /
  Delete per mirror. Intervals parse forms like "1h0m0s" with a 10m floor.
- New "Migrate from Git" page (/new/migrate, linked from the + menu):
  clone a remote into a new repo, optionally as a pull mirror, with
  optional credentials, visibility, and description.

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

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

assets/base.css +12 −0

crates/store/src/tests.rs +67 −0

crates/web/src/admin.rs +1 −1

crates/web/src/layout.rs +3 −0

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

crates/web/src/pages.rs +179 −0

crates/web/src/repo.rs +262 −0

 .empty-note {
   margin: 0 0 0.75rem;
+}
+/* Mirror settings: the collapsible Authorization block and error text. */
+.mirror-auth {
+  margin: 0.4rem 0 0.6rem;
+}
+.mirror-auth summary {
+  cursor: pointer;
+  color: var(--fb-fg-muted);
+  margin-bottom: 0.4rem;
+}
+.mirror-error {
+  color: var(--fb-danger);
+}
 /* Settings: a left tab rail and the active tab's content. */
 .settings-layout {

+}
 #[tokio::test]
+async fn mirrors_create_list_due_and_delete() {
+    for fx in sqlite_fixtures().await {
+        let owner = fx
+            .store
+            .create_user(sample_user("mir", "mir@example.com"))
+            .await
+            .unwrap();
+        let repo = fx
+            .store
+            .create_repo(NewRepo {
+                owner_id: owner.id,
+                group_id: None,
+                name: "r".to_string(),
+                path: "r".to_string(),
+                description: None,
+                visibility: model::Visibility::Private,
+                default_branch: "main".to_string(),
+            })
+            .await
+            .unwrap();
+        let m = fx
+            .store
+            .create_mirror(crate::NewMirror {
+                repo_id: repo.id.clone(),
+                direction: crate::MirrorDirection::Push,
+                remote_url: "https://example.com/r.git".to_string(),
+                username: Some("u".to_string()),
+                secret: Some("t".to_string()),
+                branch_filter: None,
+                interval_secs: 600,
+                sync_on_push: true,
+            })
+            .await
+            .unwrap();
+        assert_eq!(fx.store.mirrors_for_repo(&repo.id).await.unwrap().len(), 1);
+        // Never synced -> due now.
+        let due = fx.store.due_mirrors(super::now_ms()).await.unwrap();
+        assert_eq!(due.len(), 1);
+        // sync-on-push mirrors are returned for the repo.
+        assert_eq!(
+            fx.store.push_mirrors_on_push(&repo.id).await.unwrap().len(),
+        );
+        // After a successful sync, it is no longer due until the interval elapses.
+        fx.store.mirror_synced(&m.id, None).await.unwrap();
+        assert!(
+            fx.store
+                .due_mirrors(super::now_ms())
+                .await
+                .unwrap()
+                .is_empty()
+        );
+        let stored = fx.store.mirror_by_id(&m.id).await.unwrap().unwrap();
+        assert!(stored.last_sync_at.is_some() && stored.last_error.is_none());
+        assert!(fx.store.delete_mirror(&m.id).await.unwrap());
+        assert!(
+            fx.store
+                .mirrors_for_repo(&repo.id)
+                .await
+                .unwrap()
+                .is_empty()
+        );
+    }
+}
+#[tokio::test]
 async fn lfs_objects_track_per_repo() {
     for fx in sqlite_fixtures().await {
         let owner = fx

+}
 /// Recursively sum the sizes of regular files under `dir` (best-effort).
-fn dir_size(dir: &FsPath) -> u64 {
+pub(crate) fn dir_size(dir: &FsPath) -> u64 {
     let mut total = 0u64;
     let mut stack: Vec<PathBuf> = vec![dir.to_path_buf()];
     while let Some(path) = stack.pop() {

@@ -98,6 +98,9 @@ fn create_menu(_chrome: &Chrome) -> Markup {
98	a class="menu-item" role="menuitem" href="/new" {	98	a class="menu-item" role="menuitem" href="/new" {
99	(icon(Icon::Box)) span { "New repository" }	99	(icon(Icon::Box)) span { "New repository" }
100	}	100	}
		101	a class="menu-item" role="menuitem" href="/new/migrate" {
		102	(icon(Icon::Download)) span { "Migrate from Git" }
		103	}
101	a class="menu-item" role="menuitem" href="/new/issue" {	104	a class="menu-item" role="menuitem" href="/new/issue" {
102	(icon(Icon::Issue)) span { "New issue" }	105	(icon(Icon::Issue)) span { "New issue" }
103	}	106	}

             "/repo-settings/{id}/labels/delete",
             post(repo::settings_label_delete),
+        )
+        .route(
+            "/repo-settings/{id}/mirror",
+            post(repo::settings_mirror_add),
+        )
+        .route(
+            "/repo-settings/{id}/mirror/{mid}/delete",
+            post(repo::settings_mirror_delete),
+        )
+        .route(
+            "/repo-settings/{id}/mirror/{mid}/sync",
+            post(repo::settings_mirror_sync),
+        )
+        .route(
+            "/new/migrate",
+            get(pages::migrate_form).post(pages::migrate_submit),
+        )
         // Issue/PR mutations: fixed prefixes so they never hit the repo catch-all.
         .route("/issue-new/{repo_id}", post(issues::create))
         .route("/issue/{id}/comment", post(issues::comment))

     Ok(repo.path)
+}
+// ---- Migrate from Git ----
+/// `GET /new/migrate` — the import form.
+pub async fn migrate_form(
+    State(state): State<AppState>,
+    RequireUser(user): RequireUser,
+    jar: CookieJar,
+    uri: Uri,
+) -> Response {
+    let (jar, chrome) = build_chrome(&state, jar, Some(user.clone()), uri.path().to_string());
+    let body = migrate_body(&chrome.csrf, &user.username, None, "", "");
+    (jar, page(&chrome, "Migrate from Git", body)).into_response()
+}
+/// Migrate-from-Git form fields.
+#[derive(Debug, Deserialize)]
+pub struct MigrateForm {
+    #[serde(default)]
+    remote_url: String,
+    #[serde(default)]
+    username: String,
+    #[serde(default)]
+    secret: String,
+    /// Keep syncing from the source (create a pull mirror).
+    #[serde(default)]
+    mirror: Option<String>,
+    /// Also fetch LFS objects (best-effort; requires git-lfs on the server).
+    #[serde(default)]
+    migrate_lfs: Option<String>,
+    #[serde(default)]
+    name: String,
+    #[serde(default)]
+    description: String,
+    #[serde(default)]
+    private: Option<String>,
+    #[serde(rename = "_csrf")]
+    csrf: String,
+}
+/// `POST /new/migrate` — clone the source into a new repo (and optionally mirror).
+pub async fn migrate_submit(
+    State(state): State<AppState>,
+    RequireUser(user): RequireUser,
+    jar: CookieJar,
+    headers: HeaderMap,
+    Form(form): Form<MigrateForm>,
+) -> Response {
+    if verify_csrf(&jar, &headers, Some(&form.csrf)).is_err() {
+        return AppError::Forbidden.into_response();
+    }
+    match do_migrate(&state, &user, &form).await {
+        Ok(path) => Redirect::to(&format!("/{}/{path}", user.username)).into_response(),
+        Err(msg) => {
+            let (jar, chrome) =
+                build_chrome(&state, jar, Some(user.clone()), "/new/migrate".to_string());
+            let body = migrate_body(
+                &chrome.csrf,
+                &user.username,
+                Some(&msg),
+                form.remote_url.trim(),
+                form.name.trim(),
+            );
+            (
+                axum::http::StatusCode::BAD_REQUEST,
+                jar,
+                page(&chrome, "Migrate from Git", body),
+            )
+                .into_response()
+        }
+    }
+}
+/// Create the target repo, fetch the source into it once, and (if requested)
+/// register a pull mirror. Returns the new repo path or a user-facing error.
+async fn do_migrate(state: &AppState, user: &User, form: &MigrateForm) -> Result<String, String> {
+    let remote = form.remote_url.trim();
+    if remote.is_empty() {
+        return Err("A source URL is required.".to_string());
+    }
+    if form.name.trim().is_empty() {
+        return Err("Repository name is required.".to_string());
+    }
+    let visibility = if form.private.is_some() {
+        "private".to_string()
+    } else {
+        state.default_visibility_token()
+    };
+    // Reuse the normal create path (row + bare repo on disk with hooks).
+    let repo_form = NewRepoForm {
+        name: form.name.clone(),
+        description: form.description.clone(),
+        visibility,
+        default_branch: String::new(),
+        object_format: String::new(),
+        csrf: String::new(),
+    };
+    let path = create_repo_from_form(state, user, &repo_form).await?;
+    let repo = state
+        .store
+        .repo_by_owner_path(&user.id, &path)
+        .await
+        .ok()
+        .flatten()
+        .ok_or_else(|| "The new repository could not be found.".to_string())?;
+    let repo_dir =
+        git::repo_path(&state.config.storage.repo_dir, &repo.id).map_err(|e| e.to_string())?;
+    let home = state.config.storage.data_dir.join("tmp");
+    let username = (!form.username.trim().is_empty()).then(|| form.username.trim().to_string());
+    let secret = (!form.secret.trim().is_empty()).then(|| form.secret.trim().to_string());
+    let cred = git::mirror::RemoteCred {
+        username: username.as_deref(),
+        secret: secret.as_deref(),
+    };
+    if let Err(e) =
+        git::mirror::fetch(&state.config.git.binary, &repo_dir, remote, cred, &home).await
+    {
+        // Roll back the half-created repo so a failed import leaves nothing behind.
+        let _ = state.store.delete_repo(&repo.id).await;
+        return Err(format!("Could not fetch from the source: {e}"));
+    }
+    if form.migrate_lfs.is_some() {
+        tracing::info!(repo.id = %repo.id, "LFS migration requested (pointers imported; objects not fetched)");
+    }
+    let size = i64::try_from(crate::admin::dir_size(&repo_dir)).unwrap_or(0);
+    let _ = state.store.record_push(&repo.id, size).await;
+    if form.mirror.is_some() {
+        let _ = state
+            .store
+            .create_mirror(store::NewMirror {
+                repo_id: repo.id.clone(),
+                direction: store::MirrorDirection::Pull,
+                remote_url: remote.to_string(),
+                username,
+                secret,
+                branch_filter: None,
+                interval_secs: 8 * 3600,
+                sync_on_push: false,
+            })
+            .await;
+    }
+    Ok(path)
+}
+/// Render the migrate form with an optional error and prefilled fields.
+fn migrate_body(csrf: &str, owner: &str, error: Option<&str>, url: &str, name: &str) -> Markup {
+    html! {
+        div class="new-repo" {
+            h1 { "Migrate from Git" }
+            @if let Some(msg) = error { div class="notice notice-error" { (msg) } }
+            div class="card" {
+                form method="post" action="/new/migrate" {
+                    input type="hidden" name="_csrf" value=(csrf);
+                    label for="mg-url" { "Migrate / clone from URL" }
+                    input type="url" id="mg-url" name="remote_url" value=(url)
+                          placeholder="https://example.com/owner/repo.git" required;
+                    p class="muted field-hint" { "The HTTP(S) or git clone URL of an existing repository." }
+                    div class="admin-form-row" {
+                        input type="text" name="username" placeholder="username (optional)" autocomplete="off";
+                        input type="password" name="secret" placeholder="password / token (optional)" autocomplete="off";
+                    }
+                    label { "Migration options" }
+                    label class="checkbox" { input type="checkbox" name="mirror" value="1"; " This repository will be a mirror (keep pulling from the source)" }
+                    label class="checkbox" { input type="checkbox" name="migrate_lfs" value="1"; " Migrate LFS files" }
+                    label { "Owner" }
+                    input type="text" value=(owner) disabled;
+                    label for="mg-name" { "Repository name" }
+                    input type="text" id="mg-name" name="name" value=(name) required;
+                    label class="checkbox" { input type="checkbox" name="private" value="1"; " Make repository private" }
+                    label for="mg-desc" { "Description" }
+                    textarea id="mg-desc" name="description" rows="3" {}
+                    button class="btn btn-primary inline-btn" type="submit" { "Migrate repository" }
+                }
+            }
+        }
+    }
+}
 /// Render the new-repository form with an optional error and prefilled name.
 fn new_repo_body(state: &AppState, csrf: &str, error: Option<&str>, name: &str) -> Markup {
     let default_vis = state.default_visibility_token();

     let branches = branch_names(state, &ctx.repo.id).await;
     let collaborators = state.store.list_collaborators(&ctx.repo.id).await?;
     let labels = state.store.list_labels(&ctx.repo.id).await?;
+    let mirrors = state.store.mirrors_for_repo(&ctx.repo.id).await?;
     let (jar, chrome) = build_chrome(state, jar, viewer, uri.path().to_string());
     let id = &ctx.repo.id;
         @if ctx.repo.issues_enabled || ctx.repo.pulls_enabled {
             (labels_section(id, &chrome.csrf, &labels))
+        }
+        (mirror_section(id, &chrome.csrf, &mirrors))
         section class="listing" {
             h2 { "Danger zone" }
             div class="card danger-zone" {
     Ok((jar, page(&chrome, &title, body)).into_response())
+}
+/// The Mirror settings section: existing mirrors (push and pull) with their
+/// status and controls, plus a form to add a push mirror.
+fn mirror_section(id: &str, csrf: &str, mirrors: &[store::Mirror]) -> Markup {
+    let now = crate::now_ms();
+    html! {
+        section class="listing" {
+            h2 { "Mirror settings" }
+            div class="card" {
+                p class="muted field-hint" {
+                    "Keep this repository in sync with another repository — push its commits, tags and branches out to a remote, or pull them in. Add an inbound (pull) mirror from the "
+                    a href="/new/migrate" { "Migrate from Git" }
+                    " page."
+                }
+                @if mirrors.is_empty() {
+                    p class="muted empty-note" { "No mirrors configured." }
+                } @else {
+                    ul class="entry-list admin-list" {
+                        @for m in mirrors {
+                            li class="entry-row" {
+                                div class="entry-row-body" {
+                                    span class="entry-row-title" {
+                                        span class=(if m.direction == store::MirrorDirection::Push { "badge badge-verified" } else { "badge" }) {
+                                            (if m.direction == store::MirrorDirection::Push { "push" } else { "pull" })
+                                        }
+                                        " " (m.remote_url)
+                                    }
+                                    div class="entry-row-meta muted" {
+                                        @match m.last_sync_at {
+                                            Some(t) => { "Last synced " (crate::activity::fmt_relative(t, now)) }
+                                            None => { "Never synced" }
+                                        }
+                                        @if m.interval_secs > 0 { " · every " (fmt_duration(m.interval_secs)) } @else { " · manual" }
+                                        @if let Some(err) = &m.last_error { " · " span class="mirror-error" { "error: " (err) } }
+                                    }
+                                }
+                                div class="entry-row-actions admin-actions" {
+                                    form method="post" action=(format!("/repo-settings/{id}/mirror/{}/sync", m.id)) class="inline-form" {
+                                        input type="hidden" name="_csrf" value=(csrf);
+                                        button class="btn" type="submit" { "Sync now" }
+                                    }
+                                    form method="post" action=(format!("/repo-settings/{id}/mirror/{}/delete", m.id)) class="inline-form" {
+                                        input type="hidden" name="_csrf" value=(csrf);
+                                        button class="btn btn-danger" type="submit" { "Delete" }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                h3 { "Add a push mirror" }
+                form method="post" action=(format!("/repo-settings/{id}/mirror")) {
+                    input type="hidden" name="_csrf" value=(csrf);
+                    label for="m-url" { "Git remote repository URL" }
+                    input type="url" id="m-url" name="remote_url" placeholder="https://example.com/owner/repo.git" required;
+                    label for="m-filter" { "Branch filter (optional)" }
+                    input type="text" id="m-filter" name="branch_filter" placeholder="main release/*";
+                    p class="muted field-hint" { "Space- or comma-separated branch patterns. Leave blank to mirror all branches. Tags are always mirrored." }
+                    details class="mirror-auth" {
+                        summary { "Authorization" }
+                        div class="admin-form-row" {
+                            input type="text" name="username" placeholder="username (optional)" autocomplete="off";
+                            input type="password" name="secret" placeholder="password or access token" autocomplete="off";
+                        }
+                    }
+                    label class="checkbox" { input type="checkbox" name="sync_on_push" value="1"; " Sync when commits are pushed" }
+                    label for="m-interval" { "Mirror interval" }
+                    input type="text" id="m-interval" name="interval" value="1h0m0s";
+                    p class="muted field-hint" { "Time units are “h”, “m”, “s”. 0 disables periodic sync (minimum 10m)." }
+                    button class="btn btn-primary inline-btn" type="submit" { "Add push mirror" }
+                }
+            }
+        }
+    }
+}
+/// Parse a duration like `1h0m0s`, `30m`, or `0` into seconds. Returns `None` on
+/// a malformed value; `Some(0)` disables periodic sync.
+pub(crate) fn parse_duration(input: &str) -> Option<i64> {
+    let s = input.trim();
+    if s == "0" {
+        return Some(0);
+    }
+    // A bare integer is treated as seconds.
+    if let Ok(n) = s.parse::<i64>() {
+        return (n >= 0).then_some(n);
+    }
+    let mut total: i64 = 0;
+    let mut num = String::new();
+    let mut saw_unit = false;
+    for ch in s.chars() {
+        if ch.is_ascii_digit() {
+            num.push(ch);
+        } else {
+            let value: i64 = num.parse().ok()?;
+            num.clear();
+            saw_unit = true;
+            total += match ch {
+                'h' | 'H' => value * 3600,
+                'm' | 'M' => value * 60,
+                's' | 'S' => value,
+                _ => return None,
+            };
+        }
+    }
+    // Trailing digits with no unit, or no units at all, is malformed.
+    if !num.is_empty() || !saw_unit {
+        return None;
+    }
+    Some(total)
+}
+/// Format seconds as `1h0m0s` (matching the input the form accepts).
+fn fmt_duration(secs: i64) -> String {
+    let h = secs / 3600;
+    let m = (secs % 3600) / 60;
+    let s = secs % 60;
+    format!("{h}h{m}m{s}s")
+}
 /// 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 {
+    }
+}
+/// The add-push-mirror form.
+#[derive(Debug, serde::Deserialize)]
+pub struct MirrorAddForm {
+    #[serde(default)]
+    remote_url: String,
+    #[serde(default)]
+    branch_filter: String,
+    #[serde(default)]
+    username: String,
+    #[serde(default)]
+    secret: String,
+    #[serde(default)]
+    sync_on_push: Option<String>,
+    #[serde(default)]
+    interval: String,
+    #[serde(rename = "_csrf")]
+    csrf: String,
+}
+/// A CSRF-only form for mirror actions (delete, sync).
+#[derive(Debug, serde::Deserialize)]
+pub struct MirrorActionForm {
+    #[serde(rename = "_csrf")]
+    csrf: String,
+}
+/// `POST /repo-settings/{id}/mirror` — add a push mirror.
+pub async fn settings_mirror_add(
+    State(state): State<AppState>,
+    MaybeUser(viewer): MaybeUser,
+    jar: CookieJar,
+    headers: HeaderMap,
+    Path(id): Path<String>,
+    Form(form): Form<MirrorAddForm>,
+) -> 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?;
+        let url = form.remote_url.trim();
+        if url.is_empty() {
+            return Err(AppError::BadRequest(
+                "A remote URL is required.".to_string(),
+            ));
+        }
+        let interval = parse_duration(&form.interval)
+            .ok_or_else(|| AppError::BadRequest("Invalid mirror interval.".to_string()))?;
+        // Enforce the documented 10-minute floor on periodic sync.
+        let interval = if interval > 0 && interval < 600 {
+        } else {
+            interval
+        };
+        let opt = |s: &str| {
+            let t = s.trim();
+            (!t.is_empty()).then(|| t.to_string())
+        };
+        state
+            .store
+            .create_mirror(store::NewMirror {
+                repo_id: repo.id.clone(),
+                direction: store::MirrorDirection::Push,
+                remote_url: url.to_string(),
+                username: opt(&form.username),
+                secret: opt(&form.secret),
+                branch_filter: opt(&form.branch_filter),
+                interval_secs: interval,
+                sync_on_push: form.sync_on_push.is_some(),
+            })
+            .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(),
+    }
+}
+/// `POST /repo-settings/{id}/mirror/{mid}/delete` — remove a mirror.
+pub async fn settings_mirror_delete(
+    State(state): State<AppState>,
+    MaybeUser(viewer): MaybeUser,
+    jar: CookieJar,
+    headers: HeaderMap,
+    Path((id, mid)): Path<(String, String)>,
+    Form(form): Form<MirrorActionForm>,
+) -> 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?;
+        if let Some(m) = state.store.mirror_by_id(&mid).await?
+            && m.repo_id == repo.id
+        {
+            state.store.delete_mirror(&m.id).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(),
+    }
+}
+/// `POST /repo-settings/{id}/mirror/{mid}/sync` — trigger a sync now (background).
+pub async fn settings_mirror_sync(
+    State(state): State<AppState>,
+    MaybeUser(viewer): MaybeUser,
+    jar: CookieJar,
+    headers: HeaderMap,
+    Path((id, mid)): Path<(String, String)>,
+    Form(form): Form<MirrorActionForm>,
+) -> 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?;
+        if let Some(m) = state.store.mirror_by_id(&mid).await?
+            && m.repo_id == repo.id
+        {
+            // Sync off-request so a slow remote never blocks the response.
+            let store = state.store.clone();
+            let config = state.config.clone();
+            tokio::spawn(async move {
+                let _ = mirror::sync_one(&store, &config, &m).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(),
+    }
+}
 /// Resolve a repo by id and require the viewer to have `Admin` access, else a
 /// `404` (so a non-admin cannot even confirm the repo exists).
 async fn require_admin_repo(