Repository settings: one page per setting under a grouped sidebar (#278) c7067c7bda56

## Unreleased

- **Proposal lists and the proposals API are much faster on large files:** listing a repository's proposals rendered every open proposal's full diff and looked up each new line's history separately, recomputing a whole file's lines for every line; lists, the API, auto-land and the checks after a push now skip the rendering, and the proposal page computes each file's lines once.

- **Keyless agents can push release tags (andymccall/oxygen#129):** A tag signed by a key the hub certified (an agent's or a Flow job's ten-minute key) was refused "unknown key", and then refused by the policy. With oxy's fix the hub accepts it under the policy's subject grant and countersigns when it accepted it, as it does a bookmark move. It logs the tag's acceptance in the transparency log beside the tag, and serves both with the tag in every refs answer, so a client fetching the tag months later checks the certificate at the hub's time. Runners read repositories with their own oxy, so they need rebuilding to check such tags; older ones ignore the new fields.

- **Secret scanning finds what is already in history (#277):** push protection's rules now also run over each repository's existing history in the background (every change reachable from its bookmarks: the lines it inserts and the text files it replaces), so a credential committed before push protection existed, or while it was off, is found too. Every repository's whole history is scanned once after this deploy, then only what each push adds, a budget at a time (`[limits] history_scan_limit`, 64 MiB, and `history_scan_time_ms`, 5 s, per repository per pass; `0` turns it off), at low priority, resuming where it stopped. Maintainers see the findings, with the change, bookmark, file and line, under Settings › Push protection › Found in history, and either allow one (not a secret) or mark it resolved with how it was revoked (audited as `secret.resolved`); "Scan history now" scans the whole history again. An allowed fingerprint can now be removed (audited as `secret.bypass_removed`), so pushes adding that value are refused again. Repositories with push protection off are not scanned.

    sel.addEventListener("change", show);

    show();

  })();

})();

    let _ = writeln!(out, "  - If {is} a real credential, revoke or rotate it as well: it has been on your disk and may be elsewhere.");

    let _ = writeln!(

        out,

    );

    if !via.is_empty() {

        let _ = write!(

            out,

        );

    }

    out.trim_end().to_string()

/// Why `viewer` may not start runs here, or `None` when they may.

pub fn why_not_run(enabled: bool, signed_in: bool, role: Role) -> Option<String> {

    if !enabled {

    } else if !signed_in {

        Some("Sign in with write access to run the pipeline.".into())

    } else if role < Role::Write {

        .route("/{owner}/{name}/fork", get(forks::form).post(forks::create))

        .route("/{owner}/{name}/forks", get(forks::list))

        .route("/{owner}/{name}/settings", get(repo_settings::settings).post(repo_settings::update))

        .route("/{owner}/{name}/settings/delete", post(repo_settings::delete))

        .route("/{owner}/{name}/settings/transfer", post(repo_settings::transfer))

        .route("/{owner}/{name}/settings/archive", post(repo_settings::archive))

        .route("/{owner}/{name}/issue/{number}/project", post(projects::place_issue))

        .route("/{owner}/{name}/proposal/{number}/events", get(proposals::events))

        .route("/{owner}/{name}/settings/hooks", post(repo_settings::hooks))

        .route("/{owner}/{name}/settings/assistants/models", post(repo_settings::assistant_models))

        .route("/{owner}/{name}/settings/hooks/{id}/deliveries", get(repo_settings::deliveries))

        .route("/{owner}/{name}/settings/hooks/{id}/redeliver/{delivery}", post(repo_settings::redeliver))

        .route("/{owner}/{name}/watch", post(issues::watch))

        .route("/{owner}/{name}/star", post(issues::star))

        .route("/{owner}/{name}/edit/{r}", post(edit::save))

        .route("/{owner}/{name}/git-upload-pack", post(git_upload_pack))

        .route("/{owner}/{name}/git-receive-pack", post(git_receive_pack))

        .route("/{owner}/{name}/settings/mirror", post(repo_settings::mirror))

        .route("/{owner}/{name}/settings/flow-priority", post(repo_settings::flow_priority))

        .route("/{owner}/{name}/settings/agent-gates", post(repo_settings::agent_gates))

        .route("/{owner}/{name}/settings/secret-bypass", post(repo_settings::secret_bypass))

        .route("/{owner}/{name}/settings/secret-bypass/remove", post(repo_settings::secret_bypass_remove))

        .route("/{owner}/{name}/settings/secret-resolve", post(repo_settings::secret_resolve))

        .route("/{owner}/{name}/settings/secret-scan", post(repo_settings::secret_scan))

        .route("/{owner}/{name}/settings/flow-supersede", post(repo_settings::flow_supersede))

        .route("/{owner}/{name}/settings/runners/token", post(repo_settings::runner_token))

        .route("/{owner}/{name}/settings/runners/{id}/remove", post(repo_settings::runner_remove))

        .route("/{owner}/{name}/issues", get(issues::list))

use crate::repos::RepoName;

use crate::Shared;

use askama::Template;

use axum::response::{IntoResponse, Redirect, Response};

use hub_api::Visibility;

use serde::Deserialize;

    Ok(Redirect::to(&name.url()).into_response())

}

#[derive(Template)]

#[template(path = "repo_settings.html")]

pub struct RepoSettingsPage {

    shell: Shell,

    repo: RepoShell,

    row: db::repos::RepoRow,

    }

}

async fn settings_page(

    app: &Shared,

    shell: Shell,

    row: db::repos::RepoRow,

    role: Role,

    notice: Option<String>,

    error: Option<String>,

) -> Result<Page<RepoSettingsPage>, Error> {

    let collaborators = accounts::collaborators(&app.db, row.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let teams = match accounts::org_by_name(&app.db, &row.owner).await.map_err(|e| Error::from_db(shell.clone(), e))? {

        Some(org) => accounts::teams(&app.db, org.id).await.map_err(|e| Error::from_db(shell.clone(), e))?,

    let assistants = super::assistants::panel(app, &repo_assistants(&row)).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let variables = super::variables::panel(app, &repo_assistants(&row)).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let secrets = super::secrets::panel(app, &repo_assistants(&row)).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let coverage = crate::coverage::rules(&app.db, row.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let backup_owner = crate::backups::setting(&app.db, &row.owner).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let push_findings = db::push_protection::recent(&app.db, row.id, 50).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let resolved_findings = db::push_protection::resolved(&app.db, row.id, 50).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let history_scan_on = crate::history_scan::Budget::of(&app.config).is_some();

    Ok(Page(RepoSettingsPage {

        push_findings,

        secret_bypasses,

        history_scan,

        notice,

        error,

    }))

}

pub async fn settings(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

) -> Result<Page<RepoSettingsPage>, Error> {

}

#[derive(Deserialize)]

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<GeneralForm>,

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Maintain).await?;

    csrf(&viewer, &f.csrf_token, &shell)?;

    let e = |e| Error::from_db(shell.clone(), e);

    let topics = match db::repos::parse_topics(&f.topics) {

        Ok(t) => t,

    };

    db::repos::set_description(&app.db, row.id, f.description.trim()).await.map_err(e)?;

    db::repos::set_topics(&app.db, row.id, &topics).await.map_err(e)?;

    }

    accounts::audit(&app.db, viewer.account(), "repo.updated", &format!("{owner}/{name}"), "").await.ok();

    let row = db::repos::get_by_id(&app.db, row.id).await.map_err(e)?.unwrap_or(row);

}

#[derive(Deserialize)]

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<CollaboratorForm>,

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    csrf(&viewer, &f.csrf_token, &shell)?;

    let e = |e| Error::from_db(shell.clone(), e);

    let (account_id, team_id, label) = if !f.username.trim().is_empty() {

        match accounts::account_by_name(&app.db, f.username.trim()).await.map_err(e)? {

            Some(a) => (Some(a.id), None, a.username),

        }

    } else if !f.team.trim().is_empty() {

        let org = accounts::org_by_name(&app.db, &row.owner).await.map_err(e)?;

        };

        match team {

            Some(t) => (None, Some(t.id), format!("team {}", t.name)),

        }

    } else {

    };

    if f.remove.is_some() {

        accounts::remove_collaborator(&app.db, row.id, account_id, team_id).await.map_err(e)?;

        accounts::audit(&app.db, viewer.account(), "repo.collaborator.removed", &format!("{owner}/{name}"), &label).await.ok();

    }

    let Some(new_role) = Role::parse(&f.role) else {

    };

    accounts::set_collaborator(&app.db, row.id, account_id, team_id, new_role.as_str()).await.map_err(e)?;

    accounts::audit(

    )

    .await

    .ok();

}

#[derive(Deserialize)]

    Form(f): Form<TransferForm>,

) -> Result<Response, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    csrf(&viewer, &f.csrf_token, &shell)?;

    let me = viewer.account().cloned().ok_or_else(|| Error::not_found(shell.clone()))?;

    if f.confirm.trim() != repo.to_string() {

    }

    let to = f.owner.trim().trim_start_matches('@').to_string();

    let Some(dest) = RepoName::new(&to, &row.name) else {

    };

    if dest.owner == row.owner {

    }

    let e = |e| Error::from_db(shell.clone(), e);

    let known = accounts::account_by_name(&app.db, &dest.owner).await.map_err(e)?.is_some()

        || accounts::org_by_name(&app.db, &dest.owner).await.map_err(e)?.is_some();

    if !known {

    }

    if !roles::may_create_under(&app.db, &me, &dest.owner).await.map_err(e)? {

    }

    if db::repos::get(&app.db, &dest.owner, &dest.name).await.map_err(e)?.is_some() || app.repos.exists(&dest) {

    }

    {

        let _guard = app.repos.exclusive_guard(&repo).await;

    }

    accounts::audit(&app.db, Some(&me), "repo.transferred", &repo.to_string(), &dest.to_string()).await.ok();

    let notice = super::settings::urlencode(&format!("Moved from {repo}; the old address redirects here."));

}

#[derive(Deserialize)]

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<ArchiveForm>,

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    csrf(&viewer, &f.csrf_token, &shell)?;

    let archive = match f.action.as_str() {

        "archive" => true,

        "unarchive" => false,

    };

    let reason: String = f.reason.trim().chars().take(500).collect();

    db::repos::set_archived(&app.db, row.id, archive, &reason).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    } else {

        "The repository is back: writes are allowed again."

    };

}

/// `POST /{owner}/{name}/settings/wiki/delete`: the wiki to the trash (#104).

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<DeleteForm>,

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    csrf(&viewer, &f.csrf_token, &shell)?;

    if f.confirm.trim() != repo.to_string() {

    }

    if !crate::wiki::exists(&app, &repo) {

    }

    let _guard = app.wikis.exclusive_guard(&repo).await;

    crate::wiki::trash(&app, &repo).map_err(|e| Error::from_repo(shell.clone(), e))?;

    drop(_guard);

    accounts::audit(&app.db, viewer.account(), "wiki.data_deleted", &repo.to_string(), "moved to trash").await.ok();

}

#[derive(Deserialize)]

    Form(f): Form<DeleteForm>,

) -> Result<Response, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    csrf(&viewer, &f.csrf_token, &shell)?;

    if f.confirm.trim() != repo.to_string() {

    }

    let _guard = app.repos.exclusive_guard(&repo).await;

    app.repos.trash(&repo).map_err(|e| Error::from_repo(shell.clone(), e))?;

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<RequirementsForm>,

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    csrf(&viewer, &f.csrf_token, &shell)?;

    let r = db::proposals::Requirements {

        required_approvals: f.required_approvals.max(0),

    )

    .await

    .ok();

}

pub async fn hooks(

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<super::webhooks::HookForm>,

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    csrf(&viewer, &f.csrf_token, &shell)?;

    let scope = super::webhooks::Scope::Repo { id: row.id, slug: format!("{owner}/{name}") };

    match super::webhooks::apply(&app, &viewer, &scope, f).await.map_err(|e| Error::from_db(shell.clone(), e))? {

    }

}

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<ChecksForm>,

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    csrf(&viewer, &f.csrf_token, &shell)?;

    let names: Vec<String> = f.required_checks.split(',').map(str::trim).filter(|s| !s.is_empty()).map(String::from).collect();

    db::hooks::set_required_checks(&app.db, row.id, &names).await.map_err(|e| Error::from_db(shell.clone(), e))?;

}

#[derive(Deserialize)]

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<CoverageForm>,

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    csrf(&viewer, &f.csrf_token, &shell)?;

    let number = |v: &str, what: &str, hi: f64| -> Result<Option<f64>, String> {

        let v = v.trim().trim_end_matches('%').trim();

    };

    let rules = match (number(&f.min, "The minimum", 100.0), number(&f.max_drop, "The largest drop", 100.0)) {

        (Ok(min), Ok(max_drop)) => crate::coverage::Rules { min, max_drop },

    };

    crate::coverage::set_rules(&app.db, row.id, rules).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    accounts::audit(

    )

    .await

    .ok();

}

#[derive(Deserialize)]

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<StorageForm>,

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    csrf(&viewer, &f.csrf_token, &shell)?;

    let Some(s) = crate::storage::of(&app.db, row.id).await.map_err(|e| Error::from_db(shell.clone(), e))? else {

    };

    let scheme = s.url.split("://").next().unwrap_or("").to_string();

    let outcome = match f.action.as_str() {

    match outcome {

        Ok(notice) => {

            accounts::audit(&app.db, viewer.account(), "repo.storage", &format!("{owner}/{name}"), &f.action).await.ok();

        }

    }

}

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<BackupForm>,

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    csrf(&viewer, &f.csrf_token, &shell)?;

    if !crate::backups::REPO_CHOICES.iter().any(|(v, _)| *v == f.backup) {

    }

    db::repos::set_backup(&app.db, row.id, &f.backup).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let what = if f.backup.is_empty() { "with its owner's" } else { f.backup.as_str() };

            format!("This repository is backed up at least {} from now on.", if every == "hourly" { "every hour" } else { "every day" })

        }

    };

}

#[derive(Deserialize)]

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<DiffusionForm>,

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    csrf(&viewer, &f.csrf_token, &shell)?;

    let setting = match f.diffusion.as_str() {

        "off" | "green" | "any" => f.diffusion.as_str(),

        "default" => "",

    };

    let land = match f.land.as_str() {

        "auto" | "propose" => Some(f.land.as_str()),

        "" => None,

    };

    db::repos::set_diffusion(&app.db, row.id, setting).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    if let Some(l) = land {

        }

        crate::diffusion::Follow::Any => "Diffusion is on: every move of a subrepo's upstream opens or updates a proposal here.",

    };

}

#[derive(Deserialize)]

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<AgentGatesForm>,

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    csrf(&viewer, &f.csrf_token, &shell)?;

    let on = f.agents == "on";

    db::repos::set_agents_decide_gates(&app.db, row.id, on).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    } else {

        "Approval gates here are decided by people: agents' tokens are refused."

    };

}

#[derive(Deserialize)]

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<PushProtectionForm>,

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    csrf(&viewer, &f.csrf_token, &shell)?;

    let on = f.protect == "on";

    db::push_protection::set_enabled(&app.db, row.id, on).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    } else {

        "Push protection is off: pushes are no longer scanned for secrets here."

    };

}

#[derive(Deserialize)]

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<SecretBypassForm>,

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    csrf(&viewer, &f.csrf_token, &shell)?;

    let fingerprint = f.fingerprint.trim().to_ascii_lowercase();

    let reason = f.reason.trim();

        None

    };

    if let Some(e) = error {

    }

    let rule = db::push_protection::rule_of(&app.db, row.id, &fingerprint)

        .await

    let detail = if rule.is_empty() { format!("{fingerprint}: {reason}") } else { format!("{fingerprint} ({rule}): {reason}") };

    accounts::audit(&app.db, viewer.account(), "secret.bypass", &format!("{owner}/{name}"), &detail).await.ok();

    let notice = format!("Fingerprint {fingerprint} is allowed here: a push adding that value is no longer refused for it.");

}

#[derive(Deserialize)]

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<BypassRemoveForm>,

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    csrf(&viewer, &f.csrf_token, &shell)?;

    let fingerprint = f.fingerprint.trim().to_ascii_lowercase();

    let removed = db::push_protection::remove_bypass(&app.db, row.id, &fingerprint).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let Some(b) = removed else {

    };

    let detail = if b.rule.is_empty() {

        format!("{fingerprint} (was: {})", b.reason)

    };

    accounts::audit(&app.db, viewer.account(), "secret.bypass_removed", &format!("{owner}/{name}"), &detail).await.ok();

    let notice = format!("Fingerprint {fingerprint} is no longer allowed: a push adding that value is refused again.");

}

#[derive(Deserialize)]

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<SecretResolveForm>,

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    csrf(&viewer, &f.csrf_token, &shell)?;

    let reason = f.reason.trim();

    let error = if reason.is_empty() {

        None

    };

    if let Some(e) = error {

    }

    let by = viewer.account().map(|a| a.username.as_str()).unwrap_or("");

    let done = db::push_protection::resolve(&app.db, row.id, f.finding, by, reason).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let Some(found) = done else {

    };

    let detail = format!("{} ({}) at {}:{}: {reason}", found.fingerprint, found.rule, found.path, found.line);

    accounts::audit(&app.db, viewer.account(), "secret.resolved", &format!("{owner}/{name}"), &detail).await.ok();

    let notice = format!("The finding at {}:{} is marked resolved.", found.path, found.line);

}

#[derive(Deserialize)]

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<SecretScanForm>,

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    csrf(&viewer, &f.csrf_token, &shell)?;

    if !row.push_protection {

            None,

            Some("Turn push protection on first: history is scanned only where it is on.".into()),

    }

    crate::history_scan::request(&app, row.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    accounts::audit(&app.db, viewer.account(), "secret.history_scan", &format!("{owner}/{name}"), "requested").await.ok();

    let notice = "The whole history will be scanned again, before other repositories: findings appear below as they are found.";

}

#[derive(Deserialize)]

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<SupersedeForm>,

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    csrf(&viewer, &f.csrf_token, &shell)?;

    let keep = f.running != "on";

    db::repos::set_flow_keep_running(&app.db, row.id, keep).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    } else {

        "A new push or proposal run now cancels the older runs it supersedes, queued or running."

    };

}

#[derive(Deserialize)]

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<PriorityForm>,

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    csrf(&viewer, &f.csrf_token, &shell)?;

    let level = match f.priority.as_str() {

        "low" | "normal" | "high" => f.priority.as_str(),

        "default" => "",

    };

    if level == "high" && !viewer.is_admin() {

    }

    db::repos::set_flow_priority(&app.db, row.id, level).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    accounts::audit(

    } else {

        format!("Its jobs are {level} priority.")

    };

}

#[derive(Deserialize)]

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<FlowForm>,

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    csrf(&viewer, &f.csrf_token, &shell)?;

    let setting = match f.flow.as_str() {

        "on" => "on",

        "own" => "own",

        "off" => "off",

        "default" => "",

    };

    if !viewer.is_admin() {

        if matches!(setting, "on" | "") {

                None,

                Some("Only site administrators let the site's runners take this repository's jobs.".into()),

        }

        if setting == "own" && !has_own_runner(&app, &row).await.map_err(|e| Error::from_db(shell.clone(), e))? {

                None,

        }

    }

    db::repos::set_flow(&app.db, row.id, setting).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    } else {

        "OxygenFlow is off for this repository."

    };

}

pub async fn mirror(

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<MirrorForm>,

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    csrf(&viewer, &f.csrf_token, &shell)?;

    db::repos::set_git_mirror(&app.db, row.id, f.enabled.is_some()).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let row = db::repos::get_by_id(&app.db, row.id).await.map_err(|e| Error::from_db(shell.clone(), e))?.unwrap_or(row);

        .ok();

    let row = db::repos::get_by_id(&app.db, row.id).await.map_err(|e| Error::from_db(shell.clone(), e))?.unwrap_or(row);

    let notice = if row.git_mirror { "The Git mirror is on and up to date." } else { "The Git mirror is off." };

}

/// `POST /{owner}/{name}/settings/runners/token`: a one-time registration

        .await

        .map_err(|e| Error::from_db(shell.clone(), e))?;

    accounts::audit(&app.db, viewer.account(), "flow.runner.token", &row.slug(), "registration token for this repository").await.ok();

    page.0.runner_token = Some(token);

    Ok(page)

}

    viewer: Viewer,

    Path((owner, name, id)): Path<(String, String, i64)>,

    Form(f): Form<super::session::CsrfForm>,

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    csrf(&viewer, &f.csrf, &shell)?;

    let e = |e| Error::from_db(shell.clone(), e);

    let Some(r) = db::runners::get(&app.db, id).await.map_err(e)?.filter(|r| r.scope_repo_id == Some(row.id)) else {

        return Err(Error::not_found(shell));

    };

    if db::runners::running(&app.db).await.map_err(e)?.iter().any(|(rid, n)| *rid == id && *n > 0) {

    }

    db::runners::remove(&app.db, id).await.map_err(e)?;

    accounts::audit(&app.db, viewer.account(), "flow.runner.removed", &r.name, &row.slug()).await.ok();

}

fn repo_assistants(row: &db::repos::RepoRow) -> crate::levels::At {

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<super::assistants::AssistantForm>,

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    csrf(&viewer, &f.csrf_token, &shell)?;

    match super::assistants::apply(&app, &viewer, &repo_assistants(&row), f).await.map_err(|e| Error::from_db(shell.clone(), e))? {

    }

}

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<super::variables::VariableForm>,

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    csrf(&viewer, &f.csrf_token, &shell)?;

    match super::variables::apply(&app, &viewer, &repo_assistants(&row), f).await.map_err(|e| Error::from_db(shell.clone(), e))? {

    }

}

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<super::secrets::SecretForm>,

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    csrf(&viewer, &f.csrf_token, &shell)?;

    match super::secrets::apply(&app, &viewer, &repo_assistants(&row), f).await.map_err(|e| Error::from_db(shell.clone(), e))? {

    }

}

        }

    }

    fn label(&self) -> &str {

        match self {

            Scope::Repo { slug, .. } => slug,

    hook: db::hooks::Hook,

    rows: Vec<db::hooks::Delivery>,

    settings_url: String,

}

pub async fn deliveries_page(

        .filter(|h| scope.owns(h))

        .ok_or_else(|| Error::not_found(shell.clone()))?;

    let rows = db::hooks::deliveries_for_hook(&app.db, id, 100).await.map_err(|e| Error::from_db(shell.clone(), e))?;

}

pub async fn redeliver(app: &Shared, scope: &Scope, id: i64, delivery: i64) -> sqlx::Result<()> {

    send(app, "POST", path, cookie, Some(form)).await

}

/// Register (or sign in) and return the session cookie value.

async fn register(app: &Shared, user: &str, invite: &str) -> String {

    let r = post(

    assert_eq!(settings.status, StatusCode::OK);

    let csrf = csrf_of(&settings.body);

    let r = post(app, "/andy/secret/settings/collaborators", Some(&andy), &format!("_csrf={csrf}&username=bob&role=write")).await;

    assert_eq!(get(app, "/andy/secret", Some(&bob)).await.status, StatusCode::OK);

    assert_eq!(get(app, "/andy/secret/settings", Some(&bob)).await.status, StatusCode::NOT_FOUND, "write is not maintain");

    std::env::set_var("OXY_TOKEN", &bob_tok);

    let mut out = Vec::new();

    img.write_to(&mut std::io::Cursor::new(&mut out), image::ImageFormat::Png).unwrap();

    out