http: Remove any remaining authentication code — radicle-explorer

We also remove the /api/v1/profile endpoint because that was only supposed to be used with a local node and not publicly accessible. All fields that are still used in the UI were moved to /api/v1/node.

👉 Preview 👉 Workflow runs 👉 Branch on GitHub

 {
   "nodes": {
     "fallbackPublicExplorer": "https://app.radicle.xyz/nodes/$host/$rid$path",
     "apiVersion": "3.0.0",
     "apiVersion": "4.0.0",
     "defaultHttpdPort": 443,
     "defaultHttpdHostname": "seed.radicle.garden",
     "defaultHttpdScheme": "https",

 import { z, array, literal, number, object, string, union } from "zod";
 import * as project from "./lib/project.js";
 import * as profile from "./lib/profile.js";
 import { Fetcher } from "./lib/fetcher.js";
 import {
   nodeConfigSchema,

   agent: string(),
   config: nodeConfigSchema.nullable(),
   state: union([literal("running"), literal("stopped")]),
   avatarUrl: string().optional(),
   bannerUrl: string().optional(),
   description: string().optional(),
 });
 export type NodeInfo = z.infer<typeof nodeInfoSchema>;

   public baseUrl: BaseUrl;
   public project: project.Client;
   public profile: profile.Client;
   public constructor(baseUrl: BaseUrl) {
     this.baseUrl = baseUrl;
     this.#fetcher = new Fetcher(this.baseUrl);
     this.project = new project.Client(this.#fetcher);
     this.profile = new profile.Client(this.#fetcher);
   }
   public changePort(port: number): void {

 import type { Fetcher, RequestOptions } from "./fetcher.js";
 import type { z } from "zod";
 import { object, string } from "zod";
 import { configSchema } from "./shared.js";
 const profileSchema = object({
   config: configSchema,
   home: string(),
 });
 export type Profile = z.infer<typeof profileSchema>;
 export class Client {
   #fetcher: Fetcher;
   public constructor(fetcher: Fetcher) {
     this.#fetcher = fetcher;
   }
   public async getProfile(options?: RequestOptions): Promise<Profile> {
     return this.#fetcher.fetchOk(
       {
         method: "GET",
         path: `profile`,
         options,
       },
       profileSchema,
     );
   }
 }

 [[package]]
 name = "radicle"
 version = "0.11.1"
 version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "acd518b6fdbfb4355e261f91fa3acb9ab5f83c842714ea5e7a3f66762f17b816"
 checksum = "e8dd9d6612b6248f99f98c9e20e84649982e08bb9c35b0fff5aa521dd8f2970a"
 dependencies = [
  "amplify",
  "base64 0.21.7",

 [[package]]
 name = "radicle-httpd"
 version = "0.14.0"
 version = "0.15.0"
 dependencies = [
  "anyhow",
  "axum",

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

 url = { version = "2.5.0" }
 [dependencies.radicle]
 version = "0.11.1"
 version = "0.12.0"
 [dependencies.radicle-term]
 version = "0.10.0"

 use std::sync::Arc;
 use std::time::Duration;
 use axum::http::header::{AUTHORIZATION, CONTENT_TYPE};
 use axum::http::header::CONTENT_TYPE;
 use axum::http::Method;
 use axum::response::{IntoResponse, Json};
 use axum::routing::get;

 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 = "3.0.0";
 pub const API_VERSION: &str = "4.0.0";
 #[derive(Clone)]
 pub struct Context {

             CorsLayer::new()
                 .max_age(Duration::from_secs(86400))
                 .allow_origin(cors::Any)
                 .allow_methods([
                     Method::GET,
                     Method::POST,
                     Method::PATCH,
                     Method::PUT,
                     Method::DELETE,
                 ])
                 .allow_headers([CONTENT_TYPE, AUTHORIZATION]),
                 .allow_methods([Method::GET])
                 .allow_headers([CONTENT_TYPE]),
         )
 }

     #[error("entity not found")]
     NotFound,
     /// An error occurred during an authentication process.
     #[error("could not authenticate: {0}")]
     Auth(&'static str),
     /// An error occurred with env variables.
     #[error(transparent)]
     Env(#[from] std::env::VarError),

             Error::CobStore(e @ radicle::cob::store::Error::NotFound(_, _)) => {
                 (StatusCode::NOT_FOUND, Some(e.to_string()))
             }
             Error::Auth(msg) => (StatusCode::UNAUTHORIZED, Some(msg.to_string())),
             Error::Crypto(msg) => (StatusCode::BAD_REQUEST, Some(msg.to_string())),
             Error::Surf(radicle_surf::Error::Git(e)) if radicle::git::is_not_found_err(&e) => {
                 (StatusCode::NOT_FOUND, Some(e.message().to_owned()))

 mod delegates;
 mod node;
 mod profile;
 mod projects;
 mod stats;

     let routes = Router::new()
         .merge(root_router)
         .merge(node::router(ctx.clone()))
         .merge(profile::router(ctx.clone()))
         .merge(delegates::router(ctx.clone()))
         .merge(projects::router(ctx.clone()))
         .merge(stats::router(ctx));

                 "type": "GET"
             },
             {
                 "href": "/profile",
                 "rel": "profile",
                 "type": "GET"
             },
             {
                 "href": "/stats",
                 "rel": "stats",
                 "type": "GET"

 use axum::response::IntoResponse;
 use axum::routing::get;
 use axum::{Json, Router};
 use serde::Serialize;
 use serde_json::json;
 use radicle::crypto::ssh::fmt;
 use radicle::identity::{Did, RepoId};
 use radicle::node::address::Store as AddressStore;
 use radicle::node::routing::Store;
 use radicle::node::{AliasStore, Handle, NodeId};
 use radicle::node::{AliasStore, Config, Handle, NodeId, UserAgent};
 use radicle::Node;
 use crate::api::error::Error;

         .with_state(ctx)
 }
 #[derive(Clone, Debug, Default, Serialize)]
 #[serde(rename_all = "camelCase")]
 struct Response {
     id: String,
     agent: Option<UserAgent>,
     config: Option<Config>,
     state: String,
     #[serde(skip_serializing_if = "Option::is_none")]
     avatar_url: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     banner_url: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     description: Option<String>,
 }
 /// Return local node information.
 /// `GET /node`
 async fn node_handler(State(ctx): State<Context>) -> impl IntoResponse {

     } else {
         "stopped"
     };
     let avatar_url = ctx.profile.config.web.avatar_url.clone();
     let banner_url = ctx.profile.config.web.banner_url.clone();
     let description = ctx.profile.config.web.description.clone();
     let config = match node.config() {
         Ok(config) => Some(config),
         Err(err) => {

             None
         }
     };
     let response = json!({
         "id": node_id.to_string(),
         "agent": agent,
         "config": config,
         "state": node_state,
     });
     Ok::<_, Error>(Json(response))
     let response = Response {
         id: node_id.to_string(),
         agent,
         config,
         state: node_state.to_owned(),
         avatar_url,
         banner_url,
         description,
     };
     Ok::<_, Error>(Json(json!(response)))
 }
 /// Return stored information about other nodes.

 use std::net::SocketAddr;
 use axum::extract::{ConnectInfo, State};
 use axum::response::IntoResponse;
 use axum::routing::get;
 use axum::{Json, Router};
 use serde_json::json;
 use crate::api::error::Error;
 use crate::api::Context;
 pub fn router(ctx: Context) -> Router {
     Router::new()
         .route("/profile", get(profile_handler))
         .with_state(ctx)
 }
 /// Return local profile information.
 /// `GET /profile`
 async fn profile_handler(
     State(ctx): State<Context>,
     ConnectInfo(addr): ConnectInfo<SocketAddr>,
 ) -> impl IntoResponse {
     if !addr.ip().is_loopback() {
         return Err(Error::Auth("Profile data is only shown for localhost"));
     }
     Ok::<_, Error>(Json(
         json!({ "config": ctx.profile.config, "home": ctx.profile.home.path() }),
     ))
 }
 #[cfg(test)]
 mod routes {
     use std::net::SocketAddr;
     use axum::extract::connect_info::MockConnectInfo;
     use axum::http::StatusCode;
     use serde_json::json;
     use crate::test::{self, get};
     #[tokio::test]
     async fn test_remote_profile() {
         let tmp = tempfile::tempdir().unwrap();
         let seed = test::seed(tmp.path());
         let app = super::router(seed.clone())
             .layer(MockConnectInfo(SocketAddr::from(([192, 168, 1, 1], 8080))));
         let response = get(&app, "/profile").await;
         assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
         assert_eq!(
             response.json().await,
             json!({
               "error": "Profile data is only shown for localhost",
               "code": 401
             })
         )
     }
     #[tokio::test]
     async fn test_profile() {
         let tmp = tempfile::tempdir().unwrap();
         let seed = test::seed(tmp.path());
         let app = super::router(seed.clone())
             .layer(MockConnectInfo(SocketAddr::from(([127, 0, 0, 1], 8080))));
         let response = get(&app, "/profile").await;
         assert_eq!(response.status(), StatusCode::OK);
         assert_eq!(
             response.json().await,
             json!({
               "config": {
                 "publicExplorer": "https://app.radicle.xyz/nodes/$host/$rid$path",
                 "preferredSeeds": [
                   "z6MkrLMMsiPWUcNPHcRajuMi9mDfYckSoJyPwwnknocNYPm7@seed.radicle.garden:8776",
                   "z6Mkmqogy2qEM2ummccUthFEaaHvyYmYBYh3dbe9W4ebScxo@ash.radicle.garden:8776"
                 ],
                 "web": { "pinned": { "repositories": [] } },
                 "cli": {
                   "hints": true
                 },
                 "node": {
                   "alias": "seed",
                   "listen": [],
                   "peers": { "type": "dynamic" },
                   "connect": [],
                   "externalAddresses": [],
                   "network": "main",
                   "log": "INFO",
                   "relay": "auto",
                   "limits": {
                     "routingMaxSize": 1000,
                     "routingMaxAge": 604800,
                     "gossipMaxAge": 1209600,
                     "fetchConcurrency": 1,
                     "maxOpenFiles": 4096,
                     "rate": {
                       "inbound": {
                         "fillRate": 5.0,
                         "capacity": 1024
                       },
                       "outbound": {
                         "fillRate": 10.0,
                         "capacity": 2048
                       }
                     },
                     "connection": {
                       "inbound": 128,
                       "outbound": 16
                     }
                   },
                   "workers": 8,
                   "seedingPolicy": {
                       "default": "block",
                   }
                 }
               },
               "home": seed.profile.path()
             })
         );
     }
 }

 pub async fn get(app: &Router, path: impl ToString) -> Response {
     Response(
         app.clone()
             .oneshot(request(path, Method::GET, None, None))
             .oneshot(request(path, Method::GET, None))
             .await
             .unwrap(),
     )
 }
 fn request(
     path: impl ToString,
     method: Method,
     body: Option<Body>,
     auth: Option<String>,
 ) -> Request<Body> {
     let mut request = Request::builder()
 fn request(path: impl ToString, method: Method, body: Option<Body>) -> Request<Body> {
     let request = Request::builder()
         .method(method)
         .uri(path.to_string())
         .header("Content-Type", "application/json");
     if let Some(token) = auth {
         request = request.header("Authorization", format!("Bearer {token}"));
     }
     request.body(body.unwrap_or_else(Body::empty)).unwrap()
 }

 .14.0
 \ No newline at end of file
 .15.0
 \ No newline at end of file