feat: New patch send command to send patches
Signed-off-by: Awiteb <a@4rs.nl>
This commit is contained in:
Awiteb
279
src/cli/commands/patch/send.rs
Normal file
279
src/cli/commands/patch/send.rs
Normal file
@@ -0,0 +1,279 @@
|
||||
// n34 - A CLI to interact with NIP-34 and other stuff related to codes in nostr
|
||||
// Copyright (C) 2025 Awiteb <a@4rs.nl>
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://gnu.org/licenses/gpl-3.0.html>.
|
||||
|
||||
use std::{fs, str::FromStr};
|
||||
|
||||
use bitcoin_hashes::sha1::Hash as HashSha1;
|
||||
use clap::Args;
|
||||
use futures::future;
|
||||
use nostr::{
|
||||
event::{EventBuilder, EventId, Kind, Tag, TagKind, Tags, UnsignedEvent},
|
||||
key::PublicKey,
|
||||
nips::{nip01::Coordinate, nip10::Marker},
|
||||
types::RelayUrl,
|
||||
};
|
||||
|
||||
use super::GitPatch;
|
||||
use crate::{
|
||||
cli::{
|
||||
CliConfig,
|
||||
CliOptions,
|
||||
traits::CommandRunner,
|
||||
types::{NaddrOrSet, NostrEvent, OptionNaddrOrSetVecExt, RelayOrSetVecExt},
|
||||
},
|
||||
error::N34Result,
|
||||
nostr_utils::{
|
||||
NostrClient,
|
||||
traits::{NaddrsUtils, ReposUtils},
|
||||
utils,
|
||||
},
|
||||
};
|
||||
|
||||
/// Prefix used for git patch alt.
|
||||
const PATCH_ALT_PREFIX: &str = "git patch: ";
|
||||
|
||||
#[derive(Args, Debug)]
|
||||
pub struct SendArgs {
|
||||
/// Repository address in `naddr` format (`naddr1...`), NIP-05 format
|
||||
/// (`4rs.nl/n34` or `_@4rs.nl/n34`), or a set name like `kernel`.
|
||||
///
|
||||
/// If omitted, looks for a `nostr-address` file.
|
||||
#[arg(value_name = "NADDR-NIP05-OR-SET", long = "repo")]
|
||||
naddrs: Option<Vec<NaddrOrSet>>,
|
||||
/// List of patch files to send (space separated).
|
||||
///
|
||||
/// For p-tagging users, include them in the cover letter with
|
||||
/// `nostr:npub1...`.
|
||||
#[arg(value_name = "PATCH-PATH", required = true, value_parser = parse_patch_path)]
|
||||
patches: Vec<GitPatch>,
|
||||
/// The earliest unique commit ID in the repository.
|
||||
///
|
||||
/// Can be obtained by running `git rev-parse master` (replace 'master' with
|
||||
/// your base branch name).
|
||||
#[arg(long, value_name = "COMMIT-ID")]
|
||||
euc: HashSha1,
|
||||
/// Original patch ID if this is a revision of it
|
||||
#[arg(long, value_name = "EVENT-ID")]
|
||||
original_patch: Option<NostrEvent>,
|
||||
}
|
||||
|
||||
impl CommandRunner for SendArgs {
|
||||
async fn run(self, options: CliOptions) -> N34Result<()> {
|
||||
let config = CliConfig::load_toml(&options.config_path)?;
|
||||
let naddrs = utils::naddrs_or_file(
|
||||
self.naddrs.flat_naddrs(&config.sets)?,
|
||||
&utils::nostr_address_path()?,
|
||||
)?;
|
||||
let repo_coordinates = naddrs.clone().into_coordinates();
|
||||
let relays = options.relays.clone().flat_relays(&config.sets)?;
|
||||
let user_pubk = options.pubkey().await?;
|
||||
let client = NostrClient::init(&options, &relays).await;
|
||||
|
||||
client.add_relays(&naddrs.extract_relays()).await;
|
||||
if let Some(original_patch) = &self.original_patch {
|
||||
client.add_relays(&original_patch.relays).await;
|
||||
}
|
||||
let relays_list = client.user_relays_list(user_pubk).await?;
|
||||
client
|
||||
.add_relays(&utils::add_read_relays(relays_list.as_ref()))
|
||||
.await;
|
||||
let repos_relays = client
|
||||
.fetch_repos(&repo_coordinates)
|
||||
.await?
|
||||
.extract_relays();
|
||||
client.add_relays(&repos_relays).await;
|
||||
|
||||
let (events, events_write_relays) = make_patch_series(
|
||||
&client,
|
||||
self.patches,
|
||||
self.original_patch.as_ref().map(|e| e.event_id),
|
||||
repos_relays.first().cloned(),
|
||||
repo_coordinates,
|
||||
&self.euc,
|
||||
user_pubk,
|
||||
)
|
||||
.await?;
|
||||
|
||||
let write_relays = [
|
||||
relays,
|
||||
repos_relays,
|
||||
events_write_relays,
|
||||
naddrs.extract_relays(),
|
||||
self.original_patch.map(|e| e.relays).unwrap_or_default(),
|
||||
utils::add_write_relays(relays_list.as_ref()),
|
||||
future::join_all(
|
||||
naddrs
|
||||
.iter()
|
||||
.map(|c| client.read_relays_from_user(c.public_key)),
|
||||
)
|
||||
.await
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.collect(),
|
||||
]
|
||||
.concat();
|
||||
|
||||
tracing::trace!(write_relays = ?write_relays, "Write relays of the patches");
|
||||
let nevents = future::join_all(events.into_iter().map(|mut event| {
|
||||
async {
|
||||
let event_id = event.id();
|
||||
let subject = event
|
||||
.tags
|
||||
.find(TagKind::Alt)
|
||||
.and_then(Tag::content)
|
||||
.expect("There is an alt")
|
||||
.replace(PATCH_ALT_PREFIX, "")
|
||||
.to_string();
|
||||
client
|
||||
.send_event_to(event, relays_list.as_ref(), &write_relays)
|
||||
.await
|
||||
.map(|r| Ok((subject, utils::new_nevent(event_id, &r)?)))?
|
||||
}
|
||||
}))
|
||||
.await
|
||||
.into_iter()
|
||||
.collect::<N34Result<Vec<_>>>()?;
|
||||
|
||||
for (subject, nevent) in nevents {
|
||||
println!("Created '{subject}': {nevent}");
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn parse_patch_path(patch_path: &str) -> Result<GitPatch, String> {
|
||||
tracing::debug!("Parsing patch file `{patch_path}`");
|
||||
let patch_content = fs::read_to_string(patch_path)
|
||||
.map_err(|err| format!("Failed to read patch file `{patch_path}`: {err}"))?;
|
||||
GitPatch::from_str(&patch_content)
|
||||
}
|
||||
|
||||
async fn make_patch_series(
|
||||
client: &NostrClient,
|
||||
patches: Vec<GitPatch>,
|
||||
original_patch: Option<EventId>,
|
||||
relay_hint: Option<RelayUrl>,
|
||||
repo_coordinates: Vec<Coordinate>,
|
||||
euc: &HashSha1,
|
||||
author_pkey: PublicKey,
|
||||
) -> N34Result<(Vec<UnsignedEvent>, Vec<RelayUrl>)> {
|
||||
let mut write_relays = Vec::new();
|
||||
let mut patch_series = Vec::new();
|
||||
let mut patches = patches.into_iter();
|
||||
let root_patch = patches.next().expect("Patches can't be empty");
|
||||
let (root_event, root_relays) = make_patch(
|
||||
client,
|
||||
root_patch,
|
||||
None,
|
||||
original_patch,
|
||||
relay_hint.as_ref(),
|
||||
&repo_coordinates,
|
||||
euc,
|
||||
author_pkey,
|
||||
)
|
||||
.await;
|
||||
write_relays.extend(root_relays);
|
||||
let root_id = *root_event.id.as_ref().expect("There is an id");
|
||||
let mut previous_patch = root_id;
|
||||
patch_series.push(root_event);
|
||||
|
||||
for patch in patches {
|
||||
let (patch_event, patch_relays) = make_patch(
|
||||
client,
|
||||
patch,
|
||||
Some(root_id),
|
||||
Some(previous_patch),
|
||||
relay_hint.as_ref(),
|
||||
&repo_coordinates,
|
||||
euc,
|
||||
author_pkey,
|
||||
)
|
||||
.await;
|
||||
previous_patch = patch_event.id.expect("there is an id");
|
||||
write_relays.extend(patch_relays);
|
||||
patch_series.push(patch_event);
|
||||
}
|
||||
|
||||
Ok((patch_series, write_relays))
|
||||
}
|
||||
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
async fn make_patch(
|
||||
client: &NostrClient,
|
||||
patch: GitPatch,
|
||||
root: Option<EventId>,
|
||||
reply_to: Option<EventId>,
|
||||
write_relay: Option<&RelayUrl>,
|
||||
repo_coordinates: &[Coordinate],
|
||||
euc: &HashSha1,
|
||||
author_pkey: PublicKey,
|
||||
) -> (UnsignedEvent, Vec<RelayUrl>) {
|
||||
let content_details = client.parse_content(&patch.body).await;
|
||||
let content_relays = content_details.write_relays.clone();
|
||||
// NIP-34 compliance requires referencing the previous patch using `NIP-10 e
|
||||
// reply`. However, this fails for the second patch when
|
||||
// `EventBuilder::dedup_tags` is enabled because:
|
||||
// 1. The tag is treated as a duplicate based on its content (the root ID).
|
||||
// 2. The second patch would reply to the root twice:
|
||||
// - First with the 'root' marker
|
||||
// - Then with the 'reply' marker
|
||||
// The `EventBuilder::dedup_tags` function then removes the 'reply' marker as a
|
||||
// duplicate.
|
||||
let mut safe_dedup_tags = Tags::new();
|
||||
safe_dedup_tags.push(Tag::alt(format!("{PATCH_ALT_PREFIX}{}", patch.subject)));
|
||||
safe_dedup_tags.push(Tag::reference(euc.to_string()));
|
||||
safe_dedup_tags.extend(content_details.into_tags());
|
||||
safe_dedup_tags.extend(
|
||||
repo_coordinates
|
||||
.iter()
|
||||
.map(|c| Tag::coordinate(c.clone(), None)),
|
||||
);
|
||||
safe_dedup_tags.extend(
|
||||
repo_coordinates
|
||||
.iter()
|
||||
.map(|c| Tag::public_key(c.public_key)),
|
||||
);
|
||||
safe_dedup_tags.dedup();
|
||||
let mut event_builder = EventBuilder::new(Kind::GitPatch, patch.inner).tags(safe_dedup_tags);
|
||||
|
||||
// If the root is None, this indicates we're handling the root event
|
||||
if let Some(root_id) = root {
|
||||
event_builder =
|
||||
event_builder.tag(utils::event_reply_tag(&root_id, write_relay, Marker::Root));
|
||||
} else {
|
||||
event_builder = event_builder.tag(Tag::hashtag("root"));
|
||||
}
|
||||
|
||||
if let Some(reply_to_id) = reply_to {
|
||||
if root.is_none() {
|
||||
event_builder = event_builder.tags([
|
||||
utils::event_reply_tag(&reply_to_id, write_relay, Marker::Reply),
|
||||
Tag::hashtag("root-revision"),
|
||||
]);
|
||||
} else {
|
||||
event_builder = event_builder.tag(utils::event_reply_tag(
|
||||
&reply_to_id,
|
||||
write_relay,
|
||||
Marker::Reply,
|
||||
));
|
||||
}
|
||||
}
|
||||
(
|
||||
event_builder.build(author_pkey),
|
||||
content_relays.into_iter().collect(),
|
||||
)
|
||||
}
|
||||
Reference in New Issue
Block a user