Remove session and r/w functionality — radicle-explorer

radicle-httpd

Removes session endpoints.
Removes put, patch and post endpoints for issues and patches.
Removes all tests related to removed endpoints.

radicle-explorer

Removed the delegate badge from the ProjectCard component since we don’t check the local httpd anymore.
Added the id field to the patch.review schema.
- Allows to remove the undefined type from the id prop in the Comment component.
Simplified the /App/Header component since there is no right side anymore.
Removed the strictEvents attribute from the Button component, since we only forward eventlisteners.
Did also some changes to the updateNodeConfig fn and the schemas and types it uses, to make it cleaner, and allows us to use not only the node config but also the web and cli config.
Removed the SeedButton component and moved the seed count to the ContextRepo component.
Removed the isLocal util function and removed every case where we treated a local httpd instance different than a remote one.
Removed the special case in the isDomain util function to also allow a loopback address if not in production.

👉 Preview 👉 Workflow runs 👉 Branch on GitHub

     "fallbackPublicExplorer": "FALLBACK_PUBLIC_EXPLORER",
     "apiVersion": "API_VERSION",
     "defaultHttpdPort": "DEFAULT_HTTPD_PORT",
     "defaultLocalHttpdPort": "DEFAULT_LOCAL_HTTPD_PORT",
     "defaultHttpdHostname": "DEFAULT_HTTPD_HOSTNAME",
     "defaultHttpdScheme": "DEFAULT_HTTPD_SCHEME",
     "defaultNodePort": "DEFAULT_NODE_PORT",

     }
   },
   "supportWebsite": "SUPPORT_WEBSITE",
   "reactions": {
     "__name": "REACTIONS",
     "__format": "json"
   },
   "fallbackPreferredSeed": {
     "__name": "FALLBACK_PREFERRED_SEED",
     "__format": "json"

 {
   "nodes": {
     "fallbackPublicExplorer": "https://app.radicle.xyz/nodes/$host/$rid$path",
     "apiVersion": "1.2.0",
     "apiVersion": "2.0.0",
     "defaultHttpdPort": 443,
     "defaultLocalHttpdPort": 8080,
     "defaultHttpdHostname": "seed.radicle.garden",
     "defaultHttpdScheme": "https",
     "defaultNodePort": 8776,

     ]
   },
   "supportWebsite": "https://radicle.zulipchat.com",
   "reactions": ["👍", "👎", "😄", "🎉", "🙁", "🚀", "👀"],
   "fallbackPreferredSeed": {
     "hostname": "seed.radicle.garden",
     "port": 443,

 {
   "nodes": {
     "defaultHttpdPort": 8081,
     "defaultLocalHttpdPort": 8081,
     "defaultHttpdHostname": "127.0.0.1",
     "defaultHttpdScheme": "http",
     "pinned": [

   TreeStats,
 } from "./lib/project.js";
 import type {
   Config,
   SuccessResponse,
   CodeLocation,
   Range,

   Commit,
   CommitBlob,
   CommitHeader,
   Config,
   DefaultSeedingPolicy,
   Diff,
   DiffBlob,

 import type { Fetcher, RequestOptions } from "./fetcher.js";
 import type { z } from "zod";
 import { array, boolean, object, string } from "zod";
 import { nodeConfigSchema } from "./shared.js";
 import { object, string } from "zod";
 import { configSchema } from "./shared.js";
 const profileSchema = object({
   config: object({
     publicExplorer: string(),
     preferredSeeds: array(string()),
     cli: object({ hints: boolean() }),
     node: nodeConfigSchema,
   }),
   config: configSchema,
   home: string(),
 });

 const reviewSchema = object({
   author: authorSchema,
   id: string(),
   verdict: optional(union([literal("accept"), literal("reject")]).nullable()),
   comments: array(commentSchema),
   summary: string().nullable(),

 import type { ZodSchema, z } from "zod";
 import { array, literal, number, object, string, union } from "zod";
 import { array, boolean, literal, number, object, string, union } from "zod";
 export interface SuccessResponse {
   success: true;

 export type DefaultSeedingPolicy = z.infer<typeof defaultSeedingPolicySchema>;
 export const configSchema = object({
   publicExplorer: string(),
   preferredSeeds: array(string()),
   cli: object({ hints: boolean() }),
   web: object({
     pinned: object({
       repositories: array(string()),
     }),
     imageUrl: string().optional(),
     name: string().optional(),
     description: string().optional(),
   }),
   node: nodeConfigSchema,
 });
 export type Config = z.infer<typeof configSchema>;
 export const rangeSchema = union([
   object({
     type: literal("lines"),

 ]
 [[package]]
 name = "axum-auth"
 version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8169113a185f54f68614fcfc3581df585d30bf8542bcb99496990e1025e4120a"
 dependencies = [
  "async-trait",
  "axum-core",
  "base64 0.21.7",
  "http",
 ]
 [[package]]
 name = "axum-core"
 version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"

 [[package]]
 name = "radicle-httpd"
 version = "0.12.1"
 version = "0.13.0"
 dependencies = [
  "anyhow",
  "axum",
  "axum-auth",
  "axum-server",
  "base64 0.21.7",
  "chrono",

 description = "Radicle HTTP daemon"
 homepage = "https://radicle.xyz"
 license = "MIT OR Apache-2.0"
 version = "0.12.1"
 version = "0.13.0"
 authors = ["cloudhead <cloudhead@radicle.xyz>"]
 edition = "2021"
 default-run = "radicle-httpd"

 [dependencies]
 anyhow = { version = "1" }
 axum = { version = "0.7.2", default-features = false, features = ["json", "query", "tokio", "http1"] }
 axum-auth = { version= "0.7.0", default-features = false, features = ["auth-bearer"] }
 axum-server = { version = "0.6.0", default-features = false }
 base64 = "0.21.3"
 chrono = { version = "0.4.22", default-features = false, features = ["clock"] }

 pub mod auth;
 use std::collections::HashMap;
 use std::sync::Arc;
 use std::time::Duration;

 use radicle::storage::git::Repository;
 use serde::{Deserialize, Serialize};
 use serde_json::json;
 use tokio::sync::RwLock;
 use tower_http::cors::{self, CorsLayer};
 use radicle::cob::{issue, patch, Author};
 use radicle::identity::{DocAt, RepoId};
 use radicle::node::policy::Scope;
 use radicle::node::routing::Store;
 use radicle::node::AliasStore;
 use radicle::node::{Handle, NodeId};
 use radicle::node::{AliasStore, NodeId};
 use radicle::storage::{ReadRepository, ReadStorage};
 use radicle::{Node, Profile};
 use radicle::Profile;
 mod error;
 mod json;

 pub const RADICLE_VERSION: &str = env!("RADICLE_VERSION");
 // This version has to be updated on every breaking change to the radicle-httpd API.
 pub const API_VERSION: &str = "1.2.0";
 /// Identifier for sessions
 type SessionId = String;
 pub const API_VERSION: &str = "2.0.0";
 #[derive(Clone)]
 pub struct Context {
     profile: Arc<Profile>,
     sessions: Arc<RwLock<HashMap<SessionId, auth::Session>>>,
     cache: Option<Cache>,
 }

     pub fn new(profile: Arc<Profile>, options: &Options) -> Self {
         Self {
             profile,
             sessions: Default::default(),
             cache: options.cache.map(Cache::new),
         }
     }

     pub fn profile(&self) -> &Arc<Profile> {
         &self.profile
     }
     #[cfg(test)]
     pub fn sessions(&self) -> &Arc<RwLock<HashMap<SessionId, auth::Session>>> {
         &self.sessions
     }
 }
 pub fn router(ctx: Context) -> Router {

         pub seeding: usize,
     }
 }
 /// Announce refs to the network for the given RID.
 pub fn announce_refs(mut node: Node, rid: RepoId) -> Result<(), Error> {
     match node.announce_refs(rid) {
         Ok(_) => Ok(()),
         Err(e) if e.is_connection_err() => Ok(()),
         Err(e) => Err(e.into()),
     }
 }

 use serde::{Deserialize, Serialize};
 use time::serde::timestamp;
 use time::{Duration, OffsetDateTime};
 use radicle::crypto::PublicKey;
 use radicle::node::Alias;
 use crate::api::error::Error;
 use crate::api::Context;
 pub const UNAUTHORIZED_SESSIONS_EXPIRATION: Duration = Duration::seconds(60);
 pub const AUTHORIZED_SESSIONS_EXPIRATION: Duration = Duration::weeks(1);
 #[derive(Clone, Debug, Deserialize, Serialize, PartialEq)]
 #[serde(rename_all = "lowercase")]
 pub enum AuthState {
     Authorized,
     Unauthorized,
 }
 #[derive(Clone, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Session {
     pub status: AuthState,
     pub public_key: PublicKey,
     pub alias: Alias,
     #[serde(with = "timestamp")]
     pub issued_at: OffsetDateTime,
     #[serde(with = "timestamp")]
     pub expires_at: OffsetDateTime,
 }
 pub async fn validate(ctx: &Context, token: &str) -> Result<(), Error> {
     let sessions_store = ctx.sessions.read().await;
     let session = sessions_store
         .get(token)
         .ok_or(Error::Auth("Unauthorized"))?;
     if session.status != AuthState::Authorized || session.expires_at <= OffsetDateTime::now_utc() {
         return Err(Error::Auth("Unauthorized"));
     }
     Ok(())
 }

     /// Node error.
     #[error(transparent)]
     Node(#[from] radicle::node::Error),
     /// Invalid update to issue or patch.
     #[error("{0}")]
     BadRequest(String),
 }
 impl IntoResponse for Error {

             Error::StorageRef(err) if err.is_not_found() => {
                 (StatusCode::NOT_FOUND, Some(err.to_string()))
             }
             Error::BadRequest(msg) => (StatusCode::BAD_REQUEST, Some(msg)),
             other => {
                 tracing::error!("Error: {message}");
                 tracing::debug!("Error Debug: {:?}", other);

 use radicle_surf::tree::{EntryKind, Tree};
 use radicle_surf::{Commit, Oid};
 use crate::api::auth::Session;
 /// Returns JSON of a commit.
 pub(crate) fn commit(commit: &Commit) -> Value {
     json!({

     })
 }
 /// Returns JSON of a session.
 pub(crate) fn session(session_id: String, session: &Session) -> Value {
     json!({
       "sessionId": session_id,
       "status": session.status,
       "publicKey": session.public_key,
       "alias": session.alias,
       "issuedAt": session.issued_at.unix_timestamp(),
       "expiresAt": session.expires_at.unix_timestamp()
     })
 }
 /// Returns JSON for a blob with a given `path`.
 pub(crate) fn blob<T: AsRef<[u8]>>(blob: &Blob<T>, path: &str) -> Value {
     json!({

 mod node;
 mod profile;
 mod projects;
 mod sessions;
 mod stats;
 use axum::extract::State;

         .merge(root_router)
         .merge(node::router(ctx.clone()))
         .merge(profile::router(ctx.clone()))
         .merge(sessions::router(ctx.clone()))
         .merge(delegates::router(ctx.clone()))
         .merge(projects::router(ctx.clone()))
         .merge(stats::router(ctx));

 use axum::extract::State;
 use axum::response::IntoResponse;
 use axum::routing::{get, put};
 use axum::routing::get;
 use axum::{Json, Router};
 use axum_auth::AuthBearer;
 use hyper::StatusCode;
 use serde_json::json;
 use radicle::identity::RepoId;
 use radicle::node::address::Store as AddressStore;
 use radicle::node::routing::Store;
 use radicle::node::{AliasStore, Handle, NodeId, DEFAULT_TIMEOUT};
 use radicle::node::{AliasStore, Handle, NodeId};
 use radicle::Node;
 use crate::api::error::Error;
 use crate::api::{self, Context, PoliciesQuery};
 use crate::axum_extra::{Path, Query};
 use crate::api::Context;
 use crate::axum_extra::Path;
 pub fn router(ctx: Context) -> Router {
     Router::new()
         .route("/node", get(node_handler))
         .route("/node/policies/repos", get(node_policies_repos_handler))
         .route(
             "/node/policies/repos/:rid",
             put(node_policies_seed_handler)
                 .delete(node_policies_unseed_handler)
                 .get(node_policies_repo_handler),
         )
         .route("/node/policies/repos/:rid", get(node_policies_repo_handler))
         .route("/nodes/:nid", get(nodes_handler))
         .route("/nodes/:nid/inventory", get(nodes_inventory_handler))
         .with_state(ctx)

     Ok::<_, Error>(Json(*policy))
 }
 /// Seed a new repo.
 /// `PUT /node/policies/repos/:rid`
 async fn node_policies_seed_handler(
     State(ctx): State<Context>,
     AuthBearer(token): AuthBearer,
     Path(project): Path<RepoId>,
     Query(qs): Query<PoliciesQuery>,
 ) -> impl IntoResponse {
     api::auth::validate(&ctx, &token).await?;
     let mut node = Node::new(ctx.profile.socket());
     node.seed(project, qs.scope.unwrap_or_default())?;
     if let Some(from) = qs.from {
         let results = node.fetch(project, from, DEFAULT_TIMEOUT)?;
         return Ok::<_, Error>((
             StatusCode::OK,
             Json(json!({ "success": true, "results": results })),
         ));
     }
     Ok::<_, Error>((StatusCode::OK, Json(json!({ "success": true }))))
 }
 /// Unseed a repo.
 /// `DELETE /node/policies/repos/:rid`
 async fn node_policies_unseed_handler(
     State(ctx): State<Context>,
     AuthBearer(token): AuthBearer,
     Path(project): Path<RepoId>,
 ) -> impl IntoResponse {
     api::auth::validate(&ctx, &token).await?;
     let mut node = Node::new(ctx.profile.socket());
     node.unseed(project)?;
     Ok::<_, Error>((StatusCode::OK, Json(json!({ "success": true }))))
 }
 #[cfg(test)]
 mod routes {
     use std::net::SocketAddr;

 use axum::extract::{DefaultBodyLimit, State};
 use axum::http::header;
 use axum::response::IntoResponse;
 use axum::routing::{get, patch, post};
 use axum::routing::get;
 use axum::{Json, Router};
 use axum_auth::AuthBearer;
 use hyper::StatusCode;
 use radicle_surf::blob::BlobRef;
 use radicle_surf::{diff, Glob, Oid, Repository};
 use serde::{Deserialize, Serialize};
 use serde_json::json;
 use radicle::cob::{
     issue, issue::cache::Issues as _, patch, patch::cache::Patches as _, resolve_embed, Author,
     Embed, Label, Uri,
 };
 use radicle::identity::{Did, RepoId};
 use radicle::cob::{issue::cache::Issues as _, patch::cache::Patches as _, Author};
 use radicle::identity::RepoId;
 use radicle::node::routing::Store;
 use radicle::node::{AliasStore, Node, NodeId};
 use radicle::storage::{ReadRepository, ReadStorage, RemoteRepository, WriteRepository};
 use radicle::node::{AliasStore, NodeId};
 use radicle::storage::{ReadRepository, ReadStorage, RemoteRepository};
 use crate::api::error::Error;
 use crate::api::project::Info;
 use crate::api::search::{SearchQueryString, SearchResult};
 use crate::api::{self, announce_refs, CobsQuery, Context, PaginationQuery, ProjectQuery};
 use crate::api::{self, CobsQuery, Context, PaginationQuery, ProjectQuery};
 use crate::axum_extra::{cached_response, immutable_response, Path, Query};
 const MAX_BODY_LIMIT: usize = 4_194_304;

         .route("/projects/:project/remotes/:peer", get(remote_handler))
         .route("/projects/:project/blob/:sha/*path", get(blob_handler))
         .route("/projects/:project/readme/:sha", get(readme_handler))
         .route(
             "/projects/:project/issues",
             post(issue_create_handler).get(issues_handler),
         )
         .route(
             "/projects/:project/issues/:id",
             patch(issue_update_handler).get(issue_handler),
         )
         .route(
             "/projects/:project/patches",
             post(patch_create_handler).get(patches_handler),
         )
         .route(
             "/projects/:project/patches/:id",
             patch(patch_update_handler).get(patch_handler),
         )
         .route("/projects/:project/issues", get(issues_handler))
         .route("/projects/:project/issues/:id", get(issue_handler))
         .route("/projects/:project/patches", get(patches_handler))
         .route("/projects/:project/patches/:id", get(patch_handler))
         .with_state(ctx)
         .layer(DefaultBodyLimit::max(MAX_BODY_LIMIT))
 }

     Ok::<_, Error>(Json(issues))
 }
 #[derive(Debug, Deserialize, Serialize)]
 pub struct IssueCreate {
     pub title: String,
     pub description: String,
     pub labels: Vec<Label>,
     pub assignees: Vec<Did>,
     pub embeds: Vec<Embed<Uri>>,
 }
 /// Create a new issue.
 /// `POST /projects/:project/issues`
 async fn issue_create_handler(
     State(ctx): State<Context>,
     AuthBearer(token): AuthBearer,
     Path(project): Path<RepoId>,
     Json(issue): Json<IssueCreate>,
 ) -> impl IntoResponse {
     api::auth::validate(&ctx, &token).await?;
     let (repo, _) = ctx.repo(project)?;
     let node = Node::new(ctx.profile.socket());
     let signer = ctx
         .profile
         .signer()
         .map_err(|_| Error::Auth("Unauthorized"))?;
     let embeds: Vec<Embed> = issue
         .embeds
         .into_iter()
         .filter_map(|embed| resolve_embed(&repo, embed))
         .collect();
     let mut issues = ctx.profile.issues_mut(&repo)?;
     let issue = issues
         .create(
             issue.title,
             issue.description,
             &issue.labels,
             &issue.assignees,
             embeds,
             &signer,
         )
         .map_err(Error::from)?;
     announce_refs(node, repo.id())?;
     Ok::<_, Error>((
         StatusCode::CREATED,
         Json(json!({ "success": true, "id": issue.id().to_string() })),
     ))
 }
 /// Update an issue.
 /// `PATCH /projects/:project/issues/:id`
 async fn issue_update_handler(
     State(ctx): State<Context>,
     AuthBearer(token): AuthBearer,
     Path((project, issue_id)): Path<(RepoId, Oid)>,
     Json(action): Json<issue::Action>,
 ) -> impl IntoResponse {
     api::auth::validate(&ctx, &token).await?;
     let (repo, _) = ctx.repo(project)?;
     let node = Node::new(ctx.profile.socket());
     let signer = ctx.profile.signer()?;
     let mut issues = ctx.profile.issues_mut(&repo)?;
     let mut issue = issues.get_mut(&issue_id.into())?;
     let id = match action {
         issue::Action::Assign { assignees } => issue.assign(assignees, &signer)?,
         issue::Action::Lifecycle { state } => issue.lifecycle(state, &signer)?,
         issue::Action::Label { labels } => issue.label(labels, &signer)?,
         issue::Action::Edit { title } => issue.edit(title, &signer)?,
         issue::Action::Comment {
             body,
             reply_to,
             embeds,
         } => {
             let embeds: Vec<Embed> = embeds
                 .into_iter()
                 .filter_map(|embed| resolve_embed(&repo, embed))
                 .collect();
             if let Some(to) = reply_to {
                 issue.comment(body, to, embeds, &signer)?
             } else {
                 return Err(Error::BadRequest("`replyTo` missing".to_owned()));
             }
         }
         issue::Action::CommentReact {
             id,
             reaction,
             active,
         } => issue.react(id, reaction, active, &signer)?,
         issue::Action::CommentEdit { id, body, embeds } => {
             let embeds: Vec<Embed> = embeds
                 .into_iter()
                 .filter_map(|embed| resolve_embed(&repo, embed))
                 .collect();
             issue.edit_comment(id, body, embeds, &signer)?
         }
         issue::Action::CommentRedact { id } => issue.redact_comment(id, &signer)?,
     };
     announce_refs(node, repo.id())?;
     Ok::<_, Error>(Json(json!({ "success": true, "id": id })))
 }
 /// Get project issue.
 /// `GET /projects/:project/issues/:id`
 async fn issue_handler(

 mod routes {
     use std::net::SocketAddr;
     use axum::body::Body;
     use axum::extract::connect_info::MockConnectInfo;
     use axum::http::StatusCode;
     use pretty_assertions::assert_eq;

     async fn test_search_projects() {
         let tmp = tempfile::tempdir().unwrap();
         let app = super::router(seed(tmp.path()));
         let response = get(&app, format!("/projects/search?q=hello")).await;
         let response = get(&app, "/projects/search?q=hello").await;
         assert_eq!(response.status(), StatusCode::OK);
         assert_eq!(