Get radicle-desktop running on the desktop — radicle-desktop

👉 Workflow runs 👉 Branch on GitHub

 node_modules/
 # Tauri
 crates/test-http-api/target
 crates/radicle-tauri/target
 crates/radicle-tauri/gen/schemas

 checksum = "3b829e4e32b91e643de6eafe82b1d90675f5874230191a4ffbc1b336dec4d6bf"
 dependencies = [
  "async-trait",
  "axum-core",
  "axum-core 0.3.4",
  "bitflags 1.3.2",
  "bytes",
  "futures-util",

  "rustversion",
  "serde",
  "sync_wrapper 0.1.2",
  "tower",
  "tower 0.4.13",
  "tower-layer",
  "tower-service",
 ]
 [[package]]
 name = "axum"
 version = "0.7.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "504e3947307ac8326a5437504c517c4b56716c9d98fac0028c2acc7ca47d70ae"
 dependencies = [
  "async-trait",
  "axum-core 0.4.5",
  "bytes",
  "futures-util",
  "http 1.1.0",
  "http-body 1.0.1",
  "http-body-util",
  "hyper 1.5.0",
  "hyper-util",
  "itoa 1.0.11",
  "matchit",
  "memchr",
  "mime",
  "percent-encoding",
  "pin-project-lite",
  "rustversion",
  "serde",
  "serde_json",
  "serde_path_to_error",
  "serde_urlencoded",
  "sync_wrapper 1.0.1",
  "tokio",
  "tower 0.5.1",
  "tower-layer",
  "tower-service",
 ]

 ]
 [[package]]
 name = "axum-core"
 version = "0.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09f2bd6146b97ae3359fa0cc6d6b376d9539582c7b4220f041a33ec24c226199"
 dependencies = [
  "async-trait",
  "bytes",
  "futures-util",
  "http 1.1.0",
  "http-body 1.0.1",
  "http-body-util",
  "mime",
  "pin-project-lite",
  "rustversion",
  "sync_wrapper 1.0.1",
  "tower-layer",
  "tower-service",
 ]
 [[package]]
 name = "backtrace"
 version = "0.3.74"
 source = "registry+https://github.com/rust-lang/crates.io-index"

  "tonic",
  "tonic-health",
  "tonic-web",
  "tower",
  "tower-http",
  "tower 0.4.13",
  "tower-http 0.4.4",
  "tower-layer",
  "tracing",
  "tracing-core",

 checksum = "03087c2bad5e1034e8cace5926dec053fb3790248370865f5117a7d0213354c8"
 [[package]]
 name = "lexopt"
 version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baff4b617f7df3d896f97fe922b64817f6cd9a756bb81d40f8883f2f66dcb401"
 [[package]]
 name = "libappindicator"
 version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"

 dependencies = [
  "anyhow",
  "base64 0.22.1",
  "localtime",
  "log",
  "radicle",
  "radicle-surf",

 members = [
     "crates/radicle-tauri",
     "crates/radicle-types"
     "crates/radicle-types",
     "crates/test-http-api",
 ]

 anyhow = { version = "1.0.90" }
 base64 = { version = "0.22.1" }
 log = { version = "0.4.22" }
 localtime = { version = "1.3.1" }
 radicle = { git = "https://seed.radicle.xyz/z3gqcJUoA1n9HaHKufZs5FCSGazv5.git" }
 radicle-types = { version = "0.1.0", path = "../radicle-types" }
 radicle-surf = { version = "0.22.1", features = ["serde"] }

 use anyhow::anyhow;
 use radicle::crypto::ssh;
 use radicle_types::traits::auth::Auth;
 use crate::{error::Error, AppState};
 #[tauri::command]
 pub fn authenticate(ctx: tauri::State<AppState>) -> Result<(), Error> {
     let profile = &ctx.profile;
     if !profile.keystore.is_encrypted()? {
         return Ok(());
     }
     match ssh::agent::Agent::connect() {
         Ok(mut agent) => {
             if agent.request_identities()?.contains(&profile.public_key) {
                 Ok(())
             } else {
                 Err(Error::WithHint {
                     err: anyhow!("Not able to find your keys in the ssh agent"),
                     hint: "Make sure to run <code>rad auth</code> in your terminal to add your keys to the ssh-agent.",
                 })?
             }
         }
         Err(e) if e.is_not_running() => Err(Error::WithHint { err: anyhow!("SSH Agent is not running"), hint: "For now we require the user to have an ssh agent running, since we don't have passphrase inputs yet." })?,
         Err(e) => Err(e)?,
     }
 pub(crate) fn authenticate(ctx: tauri::State<AppState>) -> Result<(), Error> {
     ctx.authenticate().map_err(Error::from)
 }

 use base64::{engine::general_purpose::STANDARD, Engine as _};
 use radicle::cob;
 use radicle::git;
 use radicle::identity;
 use radicle::storage::{ReadRepository, ReadStorage};
 use radicle_types as types;
 use radicle_types::traits::cobs::Cobs;
 use radicle_types::traits::thread::Thread;
 use crate::{error, AppState};

     rid: identity::RepoId,
     oid: git::Oid,
 ) -> Result<String, error::Error> {
     let repo = ctx.profile.storage.repository(rid)?;
     let blob = repo.blob(oid)?;
     Ok::<_, error::Error>(STANDARD.encode(blob.content()))
     ctx.get_embed(rid, oid).map_err(error::Error::from)
 }
 #[tauri::command]

     name: &str,
     bytes: &[u8],
 ) -> Result<git::Oid, error::Error> {
     let repo = ctx.profile.storage.repository(rid)?;
     let embed = cob::Embed::<git::Oid>::store(name, bytes, &repo.backend)?;
     Ok::<_, error::Error>(embed.oid())
     ctx.save_embed(rid, name, bytes).map_err(error::Error::from)
 }
 #[tauri::command]

     type_name: cob::TypeName,
     id: git::Oid,
 ) -> Result<Vec<types::cobs::issue::Operation>, error::Error> {
     let aliases = ctx.profile.aliases();
     let repo = ctx.profile.storage.repository(rid)?;
     let ops = cob::store::ops(&id.into(), &type_name, &repo).unwrap();
     let mut actions: Vec<types::cobs::issue::Operation> = Vec::new();
     for op in ops.into_iter() {
         actions.extend(op.actions.iter().filter_map(
             |action: &Vec<u8>| -> Option<types::cobs::issue::Operation> {
                 let action: types::cobs::issue::Action = serde_json::from_slice(action).ok()?;
                 Some(types::cobs::issue::Operation {
                     entry_id: op.id,
                     action,
                     author: types::cobs::Author::new(op.author.into(), &aliases),
                     timestamp: op.timestamp,
                 })
             },
         ))
     }
     Ok::<_, error::Error>(actions)
 }
 mod query {
     use serde::{Deserialize, Serialize};
     use radicle::issue;
     use radicle::patch;
     #[derive(Default, Serialize, Deserialize)]
     #[serde(rename_all = "camelCase")]
     pub enum IssueStatus {
         Closed,
         #[default]
         Open,
         All,
     }
     impl IssueStatus {
         pub fn matches(&self, issue: &issue::State) -> bool {
             match self {
                 Self::Open => matches!(issue, issue::State::Open),
                 Self::Closed => matches!(issue, issue::State::Closed { .. }),
                 Self::All => true,
             }
         }
     }
     #[derive(Default, Serialize, Deserialize)]
     #[serde(rename_all = "camelCase")]
     pub enum PatchStatus {
         #[default]
         Open,
         Draft,
         Archived,
         Merged,
     }
     impl From<patch::Status> for PatchStatus {
         fn from(value: patch::Status) -> Self {
             match value {
                 patch::Status::Archived => Self::Archived,
                 patch::Status::Draft => Self::Draft,
                 patch::Status::Merged => Self::Merged,
                 patch::Status::Open => Self::Open,
             }
         }
     }
     impl From<PatchStatus> for patch::Status {
         fn from(value: PatchStatus) -> Self {
             match value {
                 PatchStatus::Archived => Self::Archived,
                 PatchStatus::Draft => Self::Draft,
                 PatchStatus::Merged => Self::Merged,
                 PatchStatus::Open => Self::Open,
             }
         }
     }
     ctx.activity_by_id(rid, type_name, id)
         .map_err(error::Error::from)
 }

 use radicle::cob;
 use radicle::cob::object::Storage;
 use radicle::git;
 use radicle::git::refs::storage::draft;
 use radicle::identity;
 use radicle::storage;
 use radicle::storage::ReadStorage;
 use radicle_types::traits::cobs::Cobs;
 use crate::error::Error;
 use crate::AppState;

     cob_id: git::Oid,
     type_name: cob::TypeName,
 ) -> Result<(), Error> {
     let signer = ctx.profile.signer()?;
     let repo = ctx.profile.storage.repository(rid)?;
     let draft_oid =
         repo.backend
             .refname_to_id(&draft::cob(signer.public_key(), &type_name, &cob_id.into()))?;
     repo.update(
         signer.public_key(),
         &type_name,
         &cob_id.into(),
         &draft_oid.into(),
     )?;
     let mut patches = ctx.profile.patches_mut(&repo)?;
     patches.write(&cob_id.into())?;
     storage::git::cob::DraftStore::new(&repo, *signer.public_key()).remove(
         signer.public_key(),
         &type_name,
         &cob_id.into(),
     )?;
     Ok::<_, Error>(())
     ctx.publish_draft(rid, cob_id, type_name)
         .map_err(Error::from)
 }

     new: types::cobs::issue::NewIssue,
     opts: types::cobs::CobOptions,
 ) -> Result<types::cobs::issue::Issue, Error> {
     let mut node = Node::new(ctx.profile.socket());
     let repo = ctx.profile.storage.repository(rid)?;
     let signer = ctx.profile.signer()?;
     let aliases = ctx.profile.aliases();
     let mut issues = ctx.profile.issues_mut(&repo)?;
     let issue = issues.create(
         new.title,
         new.description,
         &new.labels,
         &new.assignees,
         new.embeds.into_iter().map(|e| e.into()).collect::<Vec<_>>(),
         &signer,
     )?;
     if opts.announce() {
         node.announce_refs(rid)?;
     }
     Ok::<_, Error>(types::cobs::issue::Issue::new(issue.id(), &issue, &aliases))
     ctx.create_issue(rid, new, opts).map_err(Error::from)
 }
 #[tauri::command]

     action: types::cobs::issue::Action,
     opts: types::cobs::CobOptions,
 ) -> Result<types::cobs::issue::Issue, Error> {
     let mut node = Node::new(ctx.profile.socket());
     let repo = ctx.profile.storage.repository(rid)?;
     let signer = ctx.profile.signer()?;
     let aliases = ctx.profile.aliases();
     let mut issues = ctx.profile.issues_mut(&repo)?;
     let mut issue = issues.get_mut(&cob_id.into())?;
     match action {
         types::cobs::issue::Action::Lifecycle { state } => {
             issue.lifecycle(state.into(), &signer)?;
         }
         types::cobs::issue::Action::Assign { assignees } => {
             issue.assign(assignees, &signer)?;
         }
         types::cobs::issue::Action::Label { labels } => {
             issue.label(labels, &signer)?;
         }
         types::cobs::issue::Action::CommentReact {
             id,
             reaction,
             active,
         } => {
             issue.react(id, reaction, active, &signer)?;
         }
         types::cobs::issue::Action::CommentRedact { id } => {
             issue.redact_comment(id, &signer)?;
         }
         types::cobs::issue::Action::Comment {
             body,
             reply_to,
             embeds,
         } => {
             issue.comment(
                 body,
                 reply_to.unwrap_or(cob_id),
                 embeds.into_iter().map(|e| e.into()).collect::<Vec<_>>(),
                 &signer,
             )?;
         }
         types::cobs::issue::Action::CommentEdit { id, body, embeds } => {
             issue.edit_comment(
                 id,
                 body,
                 embeds.into_iter().map(|e| e.into()).collect::<Vec<_>>(),
                 &signer,
             )?;
         }
         types::cobs::issue::Action::Edit { title } => {
             issue.edit(title, &signer)?;
         }
     }
     if opts.announce() {
         node.announce_refs(rid)?;
     }
     Ok::<_, Error>(types::cobs::issue::Issue::new(issue.id(), &issue, &aliases))
     ctx.edit_issue(rid, cob_id, action, opts)
         .map_err(Error::from)
 }
 #[tauri::command]
 pub fn list_issues(
 pub(crate) fn list_issues(
     ctx: tauri::State<AppState>,
     rid: identity::RepoId,
     status: query::IssueStatus,
     status: Option<types::cobs::query::IssueStatus>,
 ) -> Result<Vec<types::cobs::issue::Issue>, Error> {
     let repo = ctx.profile.storage.repository(rid)?;
     let issues = ctx.profile.issues(&repo)?;
     let mut issues: Vec<_> = issues
         .list()?
         .filter_map(|r| {
             let (id, issue) = r.ok()?;
             (status.matches(issue.state())).then_some((id, issue))
         })
         .collect::<Vec<_>>();
     issues.sort_by(|(_, a), (_, b)| b.timestamp().cmp(&a.timestamp()));
     let aliases = &ctx.profile.aliases();
     let issues = issues
         .into_iter()
         .map(|(id, issue)| types::cobs::issue::Issue::new(&id, &issue, aliases))
         .collect::<Vec<_>>();
     Ok::<_, Error>(issues)
     ctx.list_issues(rid, status).map_err(Error::from)
 }
 #[tauri::command]
 pub fn issue_by_id(
 pub(crate) fn issue_by_id(
     ctx: tauri::State<AppState>,
     rid: identity::RepoId,
     id: git::Oid,
 ) -> Result<Option<types::cobs::issue::Issue>, Error> {
     let repo = ctx.profile.storage.repository(rid)?;
     let issues = ctx.profile.issues(&repo)?;
     let issue = issues.get(&id.into())?;
     let aliases = &ctx.profile.aliases();
     let issue = issue.map(|issue| types::cobs::issue::Issue::new(&id.into(), &issue, aliases));
     Ok::<_, Error>(issue)
     ctx.issue_by_id(rid, id).map_err(Error::from)
 }

 pub async fn list_patches(
     ctx: tauri::State<'_, AppState>,
     rid: identity::RepoId,
     status: Option<query::PatchStatus>,
     status: Option<types::cobs::query::PatchStatus>,
     skip: Option<usize>,
     take: Option<usize>,
 ) -> Result<types::cobs::PaginatedQuery<Vec<types::cobs::patch::Patch>>, Error> {
     let cursor = skip.unwrap_or(0);
     let take = take.unwrap_or(20);
     let repo = ctx.profile.storage.repository(rid)?;
     let aliases = &ctx.profile.aliases();
     let cache = ctx.profile.patches(&repo)?;
     let patches = match status {
         None => cache.list()?.collect::<Vec<_>>(),
         Some(s) => cache.list_by_status(&s.into())?.collect::<Vec<_>>(),
     };
     let more = cursor + take < patches.len();
     let mut patches = patches
         .into_iter()
         .filter_map(|p| {
             p.map(|(id, patch)| types::cobs::patch::Patch::new(id, &patch, aliases))
                 .ok()
         })
         .skip(cursor)
         .take(take)
         .collect::<Vec<_>>();
     patches.sort_by_key(|b| std::cmp::Reverse(b.timestamp()));
     Ok::<_, Error>(types::cobs::PaginatedQuery {
         cursor,
         more,
         content: patches,
     })
     ctx.list_patches(rid, status, skip, take)
         .map_err(Error::from)
 }
 #[tauri::command]

     rid: identity::RepoId,
     id: git::Oid,
 ) -> Result<Option<types::cobs::patch::Patch>, Error> {
     let repo = ctx.profile.storage.repository(rid)?;
     let patches = ctx.profile.patches(&repo)?;
     let patch = patches.get(&id.into())?;
     let aliases = &ctx.profile.aliases();
     let patches = patch.map(|patch| types::cobs::patch::Patch::new(id.into(), &patch, aliases));
     Ok::<_, Error>(patches)
     ctx.get_patch(rid, id).map_err(Error::from)
 }
 #[tauri::command]

     id: git::Oid,
     revision_id: git::Oid,
 ) -> Result<Option<types::cobs::patch::Revision>, Error> {
     let repo = ctx.profile.storage.repository(rid)?;
     let patches = ctx.profile.patches(&repo)?;
     let revision = patches.get(&id.into())?.and_then(|patch| {
         let aliases = &ctx.profile.aliases();
         patch
             .revision(&revision_id.into())
             .map(|r| types::cobs::patch::Revision::new(r.clone(), aliases))
     });
     Ok::<_, Error>(revision)
     ctx.revision_by_id(rid, id, revision_id)
         .map_err(Error::from)
 }
 /// Creates a draft review for a specific patch revision.
 ///
 /// This Tauri command allows users to create a new draft review for a specific patch revision.
 /// The draft is associated with the user (signer) and the provided patch revision within the repository.
 #[tauri::command]
 pub fn create_draft_review(
     ctx: tauri::State<AppState>,

     cob_id: git::Oid,
     labels: Vec<cob::Label>,
 ) -> Result<patch::ReviewId, Error> {
     let repo = ctx.profile.storage.repository(rid)?;
     let signer = ctx.profile.signer()?;
     let drafts = storage::git::cob::DraftStore::new(&repo, *signer.public_key());
     let mut patches = cob::patch::Cache::no_cache(&drafts)?;
     let mut patch = patches.get_mut(&cob_id.into())?;
     let revision = patch
         .revision(&revision_id)
         .ok_or_else(|| Error::WithHint {
             err: anyhow::anyhow!("patch revision not found"),
             hint: "Not able to find the specified patch revision.",
         })?;
     revision
         .review_by(signer.public_key())
         .ok_or(Error::WithHint {
             err: anyhow::anyhow!("duplicate patch review found"),
             hint: "Found an existing draft patch review on this patch revision and repo.",
         })?;
     let review_id = patch.review(
         revision.id(),
         Some(cob::patch::Verdict::Reject),
         None,
         labels,
         &signer,
     )?;
     patches.write(&cob_id.into())?;
     Ok::<_, Error>(review_id)
     ctx.create_draft_review(rid, revision_id, cob_id, labels)
         .map_err(Error::from)
 }
 /// Creates a new review comment on a draft review for a specific patch.

     cob_id: git::Oid,
     revision_id: patch::RevisionId,
 ) -> Option<patch::Review> {
     let repo = ctx.profile.storage.repository(rid).ok()?;
     let signer = ctx.profile.signer().ok()?;
     let drafts = storage::git::cob::DraftStore::new(&repo, *signer.public_key());
     let patches = cob::patch::Cache::no_cache(&drafts).ok()?;
     let patch = patches.get(&cob_id.into()).ok()?;
     let revision = patch.and_then(|p| p.revision(&revision_id).cloned());
     let review = revision.and_then(|rev| rev.review_by(signer.public_key()).cloned());
     review
     ctx.get_draft_review(rid, cob_id, revision_id)
 }
 #[tauri::command]

     action: types::cobs::patch::Action,
     opts: types::cobs::CobOptions,
 ) -> Result<types::cobs::patch::Patch, Error> {
     let mut node = Node::new(ctx.profile.socket());
     let repo = ctx.profile.storage.repository(rid)?;
     let signer = ctx.profile.signer()?;
     let aliases = ctx.profile.aliases();
     let mut patches = ctx.profile.patches_mut(&repo)?;
     let mut patch = patches.get_mut(&cob_id.into())?;
     match action {
         types::cobs::patch::Action::RevisionEdit {
             revision,
             description,
             embeds,
         } => {
             patch.edit_revision(
                 revision,
                 description,
                 embeds.into_iter().map(|e| e.into()).collect::<Vec<_>>(),
                 &signer,
             )?;
         }
         types::cobs::patch::Action::RevisionCommentRedact { revision, comment } => {
             patch.comment_redact(revision, comment, &signer)?;
         }
         types::cobs::patch::Action::ReviewCommentRedact { review, comment } => {
             patch.redact_review_comment(review, comment, &signer)?;
         }
         types::cobs::patch::Action::ReviewCommentReact {
             review,
             comment,
             reaction,
             active,
         } => {
             patch.react_review_comment(review, comment, reaction, active, &signer)?;
         }
         types::cobs::patch::Action::ReviewCommentResolve { review, comment } => {
             patch.resolve_review_comment(review, comment, &signer)?;
         }
         types::cobs::patch::Action::ReviewCommentUnresolve { review, comment } => {
             patch.unresolve_review_comment(review, comment, &signer)?;
         }
         types::cobs::patch::Action::Edit { title, target } => {
             patch.edit(title, target, &signer)?;
         }
         types::cobs::patch::Action::ReviewEdit {
             review,
             summary,
             verdict,
             labels,
         } => {
             patch.review_edit(review, verdict, summary, labels, &signer)?;
         }
         types::cobs::patch::Action::Review {
             revision,
             summary,
             verdict,
             labels,
         } => {
             patch.review(revision, verdict, summary, labels, &signer)?;
         }
         types::cobs::patch::Action::ReviewRedact { review } => {
             patch.redact_review(review, &signer)?;
         }
         types::cobs::patch::Action::ReviewComment {
             review,
             body,
             location,
             reply_to,
             embeds,
         } => {
             patch.review_comment(
                 review,
                 body,
                 location.map(|l| l.into()),
                 reply_to,
                 embeds.into_iter().map(|e| e.into()).collect::<Vec<_>>(),
                 &signer,
             )?;
         }
         types::cobs::patch::Action::ReviewCommentEdit {
             review,
             comment,
             body,
             embeds,
         } => {
             patch.edit_review_comment(
                 review,
                 comment,
                 body,
                 embeds.into_iter().map(|e| e.into()).collect::<Vec<_>>(),
                 &signer,
             )?;
         }
         types::cobs::patch::Action::Lifecycle { state } => {
             patch.lifecycle(state, &signer)?;
         }
         types::cobs::patch::Action::Assign { assignees } => {
             patch.assign(assignees, &signer)?;
         }
         types::cobs::patch::Action::Label { labels } => {
             patch.label(labels, &signer)?;
         }
         types::cobs::patch::Action::RevisionReact {
             revision,
             reaction,
             location,
             active,
         } => {
             patch.react(
                 revision,
                 reaction,
                 location.map(|l| l.into()),
                 active,
                 &signer,
             )?;
         }
         types::cobs::patch::Action::RevisionComment {
             revision,
             location,
             body,
             reply_to,
             embeds,
         } => {
             patch.comment(
                 revision,
                 body,
                 reply_to,
                 location.map(|l| l.into()),
                 embeds.into_iter().map(|e| e.into()).collect::<Vec<_>>(),
                 &signer,
             )?;
         }
         types::cobs::patch::Action::RevisionCommentEdit {
             revision,
             comment,
             body,
             embeds,
         } => {
             patch.comment_edit(
                 revision,
                 comment,
                 body,
                 embeds.into_iter().map(|e| e.into()).collect::<Vec<_>>(),
                 &signer,
             )?;
         }
         types::cobs::patch::Action::RevisionCommentReact {
             revision,
             comment,
             reaction,
             active,
         } => {
             patch.comment_react(revision, comment, reaction, active, &signer)?;
         }
         types::cobs::patch::Action::RevisionRedact { revision } => {
             patch.redact(revision, &signer)?;
         }
         types::cobs::patch::Action::Merge { .. } => {
             unimplemented!("We don't support merging of patches through the desktop")
         }
         types::cobs::patch::Action::Revision { .. } => {
             unimplemented!("We don't support creating new revisions through the desktop")
         }
     }
     if opts.announce() {
         node.announce_refs(rid)?;
     }
     Ok::<_, Error>(types::cobs::patch::Patch::new(
         *patch.id(),
         &patch,
         &aliases,
     ))
     ctx.edit_patch(rid, cob_id, action, opts)
         .map_err(Error::from)
 }

 use radicle::storage::ReadStorage;
 use radicle_surf as surf;
 use radicle::git;
 use radicle::identity;
 use serde::Deserialize;
 use serde::Serialize;
 use radicle_types::traits::repo::Repo;
 use crate::{error, AppState};
 #[derive(Serialize, Deserialize)]
 pub struct Options {
     pub base: git::Oid,
     pub head: git::Oid,
     pub unified: u32,
 }
 #[tauri::command]
 pub async fn get_diff(
     ctx: tauri::State<'_, AppState>,
     rid: identity::RepoId,
     options: Options,
     options: radicle_types::cobs::diff::Options,
 ) -> Result<surf::diff::Diff, error::Error> {
     let repo = ctx.profile.storage.repository(rid)?.backend;
     let base = repo.find_commit(*options.base)?;
     let head = repo.find_commit(*options.head)?;
     let mut opts = git::raw::DiffOptions::new();
     opts.patience(true)
         .minimal(true)
         .context_lines(options.unified);
     let mut find_opts = git::raw::DiffFindOptions::new();
     find_opts.exact_match_only(true);
     find_opts.all(true);
     let left = base.tree()?;
     let right = head.tree()?;
     let mut diff = repo.diff_tree_to_tree(Some(&left), Some(&right), Some(&mut opts))?;
     diff.find_similar(Some(&mut find_opts))?;
     let diff = surf::diff::Diff::try_from(diff)?;
     Ok::<_, error::Error>(diff)
     ctx.get_diff(rid, options).map_err(error::Error::from)
 }

 use radicle_types::config::Config;
 use radicle_types::traits::Profile;
 use crate::error::Error;
 use crate::AppState;
 #[tauri::command]
 pub fn config(ctx: tauri::State<AppState>) -> Result<Config, Error> {
     let config = Config {
         public_key: ctx.profile.public_key,
         alias: ctx.profile.config.node.alias.clone(),
         seeding_policy: ctx.profile.config.node.seeding_policy,
     };
     Ok::<_, Error>(config)
 pub fn config(ctx: tauri::State<AppState>) -> Config {
     ctx.config()
 }

 use radicle::crypto::Verified;
 use radicle::identity::doc::PayloadId;
 use radicle::identity::{DocAt, RepoId};
 use radicle::issue::cache::Issues;
 use radicle::node::routing::Store;
 use radicle::patch::cache::Patches;
 use radicle::prelude::Doc;
 use radicle::storage::git::Repository;
 use radicle::storage::ReadStorage;
 use radicle::storage::{self, ReadRepository};
 use radicle::git;
 use radicle::identity::RepoId;
 use radicle_types as types;
 use radicle_types::traits::repo::Repo;
 use crate::error::Error;
 use crate::AppState;
 #[tauri::command]
 pub fn list_repos(ctx: tauri::State<AppState>) -> Result<Vec<types::repo::RepoInfo>, Error> {
     let storage = &ctx.profile.storage;
     let policies = ctx.profile.policies()?;
     let mut repos = storage.repositories()?.into_iter().collect::<Vec<_>>();
     repos.sort_by_key(|p| p.rid);
     let infos = repos
         .into_iter()
         .filter_map(|info| {
             if !policies.is_seeding(&info.rid).unwrap_or_default() {
                 return None;
             }
             let repo = ctx.profile.storage.repository(info.rid).ok()?;
             let DocAt { doc, .. } = repo.identity_doc().ok()?;
             let repo_info = repo_info(&ctx.profile, &repo, &doc).ok()?;
             Some(repo_info)
         })
         .collect::<Vec<_>>();
     Ok::<_, Error>(infos)
     ctx.list_repos().map_err(Error::from)
 }
 #[tauri::command]

     ctx: tauri::State<AppState>,
     rid: RepoId,
 ) -> Result<types::repo::RepoInfo, Error> {
     let repo = ctx.profile.storage.repository(rid)?;
     let DocAt { doc, .. } = repo.identity_doc()?;
     let repo_info = repo_info(&ctx.profile, &repo, &doc)?;
     Ok::<_, Error>(repo_info)
     ctx.repo_by_id(rid).map_err(Error::from)
 }
 #[tauri::command]
 pub async fn diff_stats(
     ctx: tauri::State<'_, AppState>,
     rid: RepoId,
     base: String,
     head: String,
     base: git::Oid,
     head: git::Oid,
 ) -> Result<types::cobs::Stats, Error> {
     let repo = radicle_surf::Repository::open(storage::git::paths::repository(
         &ctx.profile.storage,
         &rid,
     ))?;
     let base = repo.commit(base)?;
     let commit = repo.commit(head)?;
     let diff = repo.diff(base.id, commit.id)?;
     let stats = diff.stats();
     Ok::<_, Error>(types::cobs::Stats::new(stats))
 }
 pub fn repo_info(
     profile: &radicle::Profile,
     repo: &Repository,
     doc: &Doc<Verified>,
 ) -> Result<types::repo::RepoInfo, Error> {
     let aliases = profile.aliases();
     let delegates = doc
         .delegates
         .clone()
         .into_iter()
         .map(|did| types::cobs::Author::new(did, &aliases))
         .collect::<Vec<_>>();
     let db = profile.database()?;
     let seeding = db.count(&repo.id).unwrap_or_default();
     let project = doc.payload.get(&PayloadId::project()).and_then(|payload| {
         let (_, head) = repo.head().ok()?;
         let commit = repo.commit(head).ok()?;
         let patches = profile.patches(repo).ok()?;
         let patches = patches.counts().ok()?;
         let issues = profile.issues(repo).ok()?;
         let issues = issues.counts().ok()?;
         let data: types::repo::ProjectPayloadData = (*payload).clone().try_into().ok()?;
         let meta = types::repo::ProjectPayloadMeta {
             issues,
             patches,
             head,
             last_commit_timestamp: commit.time().seconds() * 1000,
         };
         Some(types::repo::ProjectPayload::new(data, meta))
     });
     Ok::<_, Error>(types::repo::RepoInfo {
         payloads: types::repo::SupportedPayloads { project },
         delegates,
         threshold: doc.threshold,
         visibility: doc.visibility.clone().into(),
         rid: repo.id,
         seeding,
     })
     ctx.diff_stats(rid, base, head).map_err(Error::from)
 }

     new: types::cobs::thread::NewIssueComment,
     opts: types::cobs::CobOptions,
 ) -> Result<types::cobs::thread::Comment<types::cobs::Never>, Error> {
     let aliases = &ctx.profile.aliases();
     let mut node = Node::new(ctx.profile.socket());
     let signer = ctx.profile.signer()?;
     let repo = ctx.profile.storage.repository(rid)?;
     let mut issues = ctx.profile.issues_mut(&repo)?;
     let mut issue = issues.get_mut(&new.id.into())?;
     let id = new.reply_to.unwrap_or_else(|| {
         let (root_id, _) = issue.root();
         *root_id
     });
     let n = new.clone();
     let oid = issue.comment(
         n.body,
         id,
         n.embeds.into_iter().map(|e| e.into()).collect::<Vec<_>>(),
         &signer,
     )?;
     if opts.announce() {
         node.announce_refs(rid)?;
     }
     Ok(types::cobs::thread::Comment::<types::cobs::Never>::new(
         oid,
         cob::thread::Comment::new(
             *signer.public_key(),
             new.body,
             id.into(),
             None,
             new.embeds.into_iter().map(|e| e.into()).collect::<Vec<_>>(),
             LocalTime::now().into(),
         ),
         aliases,
     ))
     ctx.create_issue_comment(rid, new, opts)
         .map_err(Error::from)
 }
 #[tauri::command]

     #[error(transparent)]
     Storage(#[from] radicle::storage::Error),
     /// Types error.
     #[error(transparent)]
     Types(#[from] radicle_types::error::Error),
     /// Surf error.
     #[error(transparent)]
     Surf(#[from] radicle_surf::Error),

     profile: radicle::Profile,
 }
 impl Auth for AppState {}
 impl Repo for AppState {}
 impl Thread for AppState {}
 impl Cobs for AppState {}
 impl Issues for AppState {}
 impl IssuesMut for AppState {}
 impl Patches for AppState {}
 impl PatchesMut for AppState {}
 impl Profile for AppState {
     fn profile(&self) -> radicle::Profile {
         self.profile.clone()
     }
 }
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
     #[cfg(debug_assertions)]

 edition = "2021"
 [dependencies]
 anyhow = { version = "1.0.90" }
 base64 = { version = "0.22.1" }
 radicle = { git = "https://seed.radicle.xyz/z3gqcJUoA1n9HaHKufZs5FCSGazv5.git" }
 radicle-surf = { version = "0.22.1", features = ["serde"] }
 serde = { version = "1.0.210", features = ["derive"] }
 serde_json = { version = "1.0.132" }
 thiserror = { version = "1.0.65" }
 ts-rs = { version = "10.0.0", features = ["serde-json-impl", "no-serde-warnings"] }
 ts-rs = { version = "10.0.0", features = [ "serde-json-impl", "no-serde-warnings" ] }
 localtime = { version = "1.3.1" }

 use radicle::identity;
 use radicle::node::{Alias, AliasStore};
 pub mod diff;
 pub mod issue;
 pub mod patch;
 pub mod thread;
 #[derive(Serialize, TS)]
 #[derive(Debug, Serialize, TS)]
 #[serde(rename_all = "camelCase")]
 #[ts(export)]
 #[ts(export_to = "cob/")]

 use crate::cobs;
 #[derive(TS, Serialize)]
 #[derive(Debug, TS, Serialize)]
 #[ts(export)]
 #[ts(export_to = "cob/patch/")]
 #[serde(rename_all = "camelCase")]

     }
 }
 #[derive(Serialize, Deserialize, TS)]
 #[derive(Debug, Serialize, Deserialize, TS)]
 #[serde(rename_all = "camelCase", tag = "status")]
 #[ts(export)]
 #[ts(export_to = "cob/patch/")]