Land proposals through the API and oh proposal land 1f1eb06a9009

        .route("/repos/{owner}/{name}/proposals/{number}/land", post(land_proposal))

}

/// `POST /repos/{o}/{n}/proposals/{number}/land` (repo:write): land it as

/// the page's Land button does; `409` with the blockers when it cannot.

async fn land_proposal(

    State(app): State<Shared>,

    headers: HeaderMap,

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

) -> Result<Json<Proposal>, ApiError> {

    let c = caller(&app, &headers).await?;

    let me = c.require("repo:write")?.clone();

    let (repo, row, _) = reach(&app, &c, &owner, &name, Access::Write).await?;

    match crate::web::proposals::land_as(&app, &repo, &row, &me, number).await {

        Ok(_) => proposal(State(app), headers, Path((owner, name, number))).await,

        Err(crate::web::proposals::Landing::NotFound) => Err(not_found("no such proposal")),

        Err(crate::web::proposals::Landing::Refused(m)) => Err(ApiError(StatusCode::CONFLICT, m)),

    }

    match land_as(&app, &repo, &row, &me.account, number).await {

        Ok(_) => detail(&app, shell, &viewer, &owner, &name, number, "conversation".into(), Some("Landed.".into()), None).await,

        Err(Landing::NotFound) => Err(Error::not_found(shell)),

        Err(Landing::Refused(m)) => detail(&app, shell, &viewer, &owner, &name, number, "conversation".into(), None, Some(m)).await,

    }

}

/// Why a proposal did not land.

pub enum Landing {

    NotFound,

    Refused(String),

}

/// Land proposal `number` as `me` (hub spec §8.4), who has write access:

/// refused while it is not open or has blockers. Moves the target bookmark

/// (attested by the hub key on `me`'s behalf when they delegated to it),

/// then records, announces and audits the landing. Returns the new state.

pub async fn land_as(

    app: &Shared,

    repo: &RepoName,

    row: &db::repos::RepoRow,

    me: &accounts::Account,

    number: i64,

) -> Result<String, Landing> {

    let (owner, name) = (row.owner.clone(), row.name.clone());

    let refused = |e: String| Landing::Refused(e);

    let p = pdb::get(&app.db, row.id, number).await.map_err(|e| refused(e.to_string()))?.ok_or(Landing::NotFound)?;

    let loaded = load(app, repo, p.clone()).await.map_err(|e| refused(e.to_string()))?;

    let v = verdict(app, &loaded, row.id).await.map_err(|e| refused(e.to_string()))?;

    if !p.is_open() {

        return Err(refused(format!("Cannot land: the proposal is {}", p.state)));

    }

    if !v.blockers.is_empty() {

        return Err(refused(format!("Cannot land: {}", v.blockers.join("; "))));

    let result = match super::edit::signer_for(app, me.id).await {

        Ok(signer) => crate::repos::edits::move_bookmark(&app.repos, repo, target.clone(), heads.clone(), signer).await.map(|_| pl::state_ref(&heads).to_hex()),

                .write(repo, move |r, _| {

    let state = result.map_err(|e| refused(e.to_string()))?;

    pdb::set_state(&app.db, p.id, "landed", &state).await.map_err(|e| refused(e.to_string()))?;

    pdb::add_event(&app.db, p.id, &me.username, "landed", "from the hub").await.ok();

    crate::hooks::emit(

        app,

        row,

        "proposal.landed",

        &me.username,

        serde_json::json!({ "number": number, "target": p.target, "state": state }),

    )

    .await;

    crate::notify::deliver(

        app,

        crate::notify::Event {

            kind: "proposal.landed",

            title: format!("{owner}/{name}#{number}: {} landed", p.title),

            url: format!("/{owner}/{name}/proposal/{number}"),

            actor: me,

            repo_id: row.id,

            thread: Some(("proposal", p.id)),

            mention_text: "",

            direct: p.author_id.into_iter().collect(),

        },

    )

    .await;

    if p.target == row.default_bookmark {

        let messages: Vec<(String, String)> = loaded.changes.iter().map(|c| (c.hash.clone(), format!("{}\n{}", c.title, c.body))).collect();

        super::issues::close_from_messages(app, row, &messages).await;

    accounts::audit(&app.db, Some(me), "proposal.landed", &format!("{owner}/{name}#{number}"), "").await.ok();

    db::repos::record_push(

        &app.db,

        row.id,

        Some((me.id, me.username.as_str())),

        &[db::repos::PushOutcome {

            reference: p.target.clone(),

            ok: true,

            reason: format!("landed #{number}"),

            old_state: loaded.target_state.clone(),

            new_state: state.clone(),

            heads: loaded.heads.len() as i64,

            changes: loaded.hashes.len() as i64,

        }],

    )

    .await

    .ok();

    Ok(state)

    /// Land a proposal on its target, as the page's Land button does

    Land { number: i64 },

            }

        }

        ProposalCmd::Land { number } => {

            let p: Proposal = c.send("POST", &format!("{base}/proposals/{number}/land"), &serde_json::json!({}))?;

            if json {

                println!("{}", serde_json::to_string(&p)?);

            } else {

                println!("{} landed #{} on {}", ui::ok("✔"), p.number, p.target);

    std::fs::remove_file(&asset).unwrap();

    // A proposal from a bookmark, landed from the command line.

    c.bookmark_create("topic", None).unwrap();

    c.bookmark_switch("topic", false).unwrap();

    write(w, "topic.txt", "more\n");

    c.snapshot("test").unwrap();

    c.commit("Add topic", &[]).unwrap();

    assert!(c.push("origin", false).unwrap().iter().all(|r| r.ok));

    let (code, out, err) = oh(w, &[], &["proposal", "create", "--title", "Topic", "--from", "topic"]).await;

    assert_eq!(code, 0, "{err}");

    let n: String = out.split("proposed #").nth(1).unwrap().chars().take_while(|c| c.is_ascii_digit()).collect();

    let (_, out, _) = oh(w, &[], &["proposal", "view", &n, "--plain"]).await;

    assert!(out.contains("topic → main") && out.contains("Add topic"), "{out}");

    let (code, out, err) = oh(w, &[], &["proposal", "land", &n]).await;

    assert_eq!(code, 0, "{err}");

    assert!(out.contains(&format!("landed #{n} on main")), "{out}");

    let (code, _, err) = oh(w, &[], &["proposal", "land", &n]).await;

    assert_ne!(code, 0);

    assert!(err.contains("HTTP 409") && err.contains("landed"), "{err}");

| `oh proposal land N` | Land it on its target, as the page's Land button does |

JSON under `/api/v1`, bearer tokens, `application/json`, RFC 7807 problem responses (an unknown route too), cursor pagination (`?after=`), ETags on cacheable resources, and rate limits per token. Resources mirror the pages: `/repos/{owner}/{name}`, `/bookmarks`, `/changes/{hash}`, `/tree/{ref}/{path}`, `/file/{ref}/{path}`, `/blame`, `/history`, `/compare`, `/conflicts`, `/proposals`, `/proposals/{n}/comments|reviews|checks|files`, `POST /proposals/{n}/land` (repo:write: what the Land button does, `409` with the blockers when it cannot), `/proposals/{n}/content/{base|head}/{path}` (a changed file's bytes in the target's state or the projected state, for editor diff views), `/issues` (creating an issue can set its labels, assignees and milestone; `PATCH /issues/{n}` edits the title and body for the author or triage, and replaces labels, assignees or the milestone for triage, recording each on the timeline; unknown names are refused before anything changes), `/labels` (`POST` creates or changes one, `DELETE /labels/{name}` removes it; triage), `/milestones`, `/releases`, `/tags`, `/trust`, `/pushes`, `/hooks`, `/checks`, `/user`, `/notifications` (the caller's inbox and unread count; `/notifications/{id}/read` and `/notifications/read` mark read; scope `user:read`), `/users/{name}`, `/orgs/{name}`, `/checks/{state}` (the checks on a state, named by its hash, by its heads joined with `+`, by the one head of a single-head state, or by a bookmark), `/checks/required` (`GET`, and `PUT` of the whole list by a repository admin: the checks a proposal needs, passed, to land), `/projects/{owner}` (list, create) and `/projects/{owner}/{n}` (the board as the caller may see it, `PATCH` for title, description, privacy and closing, `/cards` to add a reference or note to a column named by id or name, `/cards/{id}` to move or remove one; `repo:write` and the page's rights to change), `/flow/runs` (`GET`: runs newest first, `?before=N&limit=`; `POST {"bookmark"}` or `{"change"}`, repo:write: run a bookmark's current state, the default bookmark when none is named, or one change's state), `/flow/runs/{n}` (a run with its jobs), `/flow/runs/{n}/jobs/{job}/log` (`?after=seq&limit=`) and `/flow/runs/{n}/rerun` (repo:write: a finished run again), both answering `201 {"number", "url"}` or `409` with why nothing started, `/search`. A change's author carries the account its key is linked to, or `null` and a `note` saying the key is not linked and where its owner links it (the change page shows a "key not linked" tag, with a link to Settings → Keys for signed-in viewers). Shapes reuse `oxy --json` shapes wherever one exists (change, status, blame, diff) so tools written against the CLI work against the hub. `crates/hub-api` holds the types with `serde` derives and is what the runner and the VS Code extension will link.