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


			@@ -1056,6 +1056,18 @@ body.drawer-open .drawer-backdrop {
1056	1056		.empty-note {
1057	1057		margin: 0 0 0.75rem;
1058	1058		}
	1059	+	/* Mirror settings: the collapsible Authorization block and error text. */
	1060	+	.mirror-auth {
	1061	+	margin: 0.4rem 0 0.6rem;
	1062	+	}
	1063	+	.mirror-auth summary {
	1064	+	cursor: pointer;
	1065	+	color: var(--fb-fg-muted);
	1066	+	margin-bottom: 0.4rem;
	1067	+	}
	1068	+	.mirror-error {
	1069	+	color: var(--fb-danger);
	1070	+	}
1059	1071
1060	1072		/* Settings: a left tab rail and the active tab's content. */
1061	1073		.settings-layout {

@@ @@ -825,6 +825,73 @@ async fn ensure_group_path_rejects_excessive_nesting() { @@
+}
 #[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	98		a class="menu-item" role="menuitem" href="/new" {
99	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	104		a class="menu-item" role="menuitem" href="/new/issue" {
102	105		(icon(Icon::Issue)) span { "New issue" }
103	106		}


			@@ -299,6 +299,22 @@ pub fn build_router(state: AppState) -> Router {
299	299		"/repo-settings/{id}/labels/delete",
300	300		post(repo::settings_label_delete),
301	301		)
	302	+	.route(
	303	+	"/repo-settings/{id}/mirror",
	304	+	post(repo::settings_mirror_add),
	305	+	)
	306	+	.route(
	307	+	"/repo-settings/{id}/mirror/{mid}/delete",
	308	+	post(repo::settings_mirror_delete),
	309	+	)
	310	+	.route(
	311	+	"/repo-settings/{id}/mirror/{mid}/sync",
	312	+	post(repo::settings_mirror_sync),
	313	+	)
	314	+	.route(
	315	+	"/new/migrate",
	316	+	get(pages::migrate_form).post(pages::migrate_submit),
	317	+	)
302	318		// Issue/PR mutations: fixed prefixes so they never hit the repo catch-all.
303	319		.route("/issue-new/{repo_id}", post(issues::create))
304	320		.route("/issue/{id}/comment", post(issues::comment))

@@ @@ -457,6 +457,185 @@ async fn create_repo_from_form( @@
     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();

@@ @@ -1004,6 +1004,7 @@ async fn repo_settings_view( @@
     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;
@@ @@ -1061,6 +1062,7 @@ async fn repo_settings_view( @@
         @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" {
@@ @@ -1076,6 +1078,125 @@ async fn repo_settings_view( @@
     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 {
@@ @@ -1283,6 +1404,147 @@ pub async fn settings_label_delete( @@
+    }
+}
 /// 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(