{

  "nodes": {

    "fallbackPublicExplorer": "FALLBACK_PUBLIC_EXPLORER",

    "defaultHttpdPort": "DEFAULT_HTTPD_PORT",

    "defaultHttpdScheme": "DEFAULT_HTTPD_SCHEME"

  },

    "commitsPerPage": "COMMITS_PER_PAGE"

  },

  "supportWebsite": "SUPPORT_WEBSITE",

  "fallbackPreferredSeed": {

    "__name": "PREFERRED_SEEDS",

    "__format": "json"

{

  "nodes": {

    "fallbackPublicExplorer": "https://app.radicle.xyz/nodes/$host/$rid$path",

    "defaultHttpdPort": 443,

    "defaultHttpdScheme": "https"

  },

    "commitsPerPage": 30

  },

  "supportWebsite": "https://radicle.zulipchat.com",

  "preferredSeeds": [

    {

      "hostname": "ash.radicle.garden",

    let description: string;

    if (!satisfies(nodeApiVersion, explorerRequiredApiVersion)) {

    } else {

    }

    this.apiVersion = apiVersion;

    this.description =

      "The response received from the seed does not match the expected schema.<br/>".concat(

        description,

      );

    this.method = method;

    params: FetchParams,

    schema: T,

  ): Promise<TypeOf<T>> {

    const response = await this.fetch({

      ...params,

    });

    if (!response.ok) {

      throw new ResponseParseError(

        params.method,

        responseBody,

        result.error.errors,

        params.path,

      );

    const pathSegment = path === undefined ? "" : `/${path}`;

    if (query) {

      const searchparams = new URLSearchParams(query as Record<string, string>);

    source: {

      commitsPerPage: number;

    };

    reactions: string[];

    supportWebsite: string;

    preferredSeeds: BaseUrl[];

[[package]]

name = "radicle"

source = "registry+https://github.com/rust-lang/crates.io-index"

dependencies = [

 "amplify",

 "base64 0.21.7",

[[package]]

name = "radicle-cob"

source = "registry+https://github.com/rust-lang/crates.io-index"

dependencies = [

 "fastrand",

 "git2",

[[package]]

name = "radicle-dag"

source = "registry+https://github.com/rust-lang/crates.io-index"

dependencies = [

 "fastrand",

]

[[package]]

name = "radicle-httpd"

dependencies = [

 "anyhow",

 "axum",

description = "Radicle HTTP daemon"

homepage = "https://radicle.xyz"

license = "MIT OR Apache-2.0"

authors = ["cloudhead <cloudhead@radicle.xyz>"]

edition = "2021"

default-run = "radicle-httpd"

tracing-subscriber = { version = "0.3.18", default-features = false, features = ["std", "ansi", "fmt"] }

[dependencies.radicle]

[dev-dependencies]

hyper = { version = "1.4", default-features = false, features = ["client"] }

    xz -d -c zig.tar.xz | tar -x && \

    mv zig-linux-x86_64-0.12.0/zig /usr/bin/zig && \

    mv zig-linux-x86_64-0.12.0/lib /usr/lib/zig && \

# Parts of the macOS SDK are required to build Radicle, we make these available

use std::collections::BTreeMap;

use std::sync::Arc;

use axum::response::{IntoResponse, Json};

use axum::routing::get;

use axum::Router;

use serde_json::{json, Value};

use radicle::identity::doc::PayloadId;

use radicle::identity::{DocAt, RepoId};

pub const RADICLE_VERSION: &str = env!("RADICLE_VERSION");

// This version has to be updated on every breaking change to the radicle-httpd API.

#[derive(Clone)]

pub struct Context {

        let aliases = self.profile.aliases();

        let delegates = doc

            .collect::<Vec<_>>();

        let db = &self.profile.database()?;

        let seeding = db.count(&rid).unwrap_or_default();

        let payloads: BTreeMap<PayloadId, Value> = doc

            .filter_map(|(id, payload)| {

                    let (_, head) = repo.head().ok()?;

                    let patches = self.profile.patches(repo).ok()?;

                    let patches = patches.counts().ok()?;

                    let issues = issues.counts().ok()?;

                    Some((

                        json!({

                            "data": payload,

                            "meta": {

                        }),

                    ))

                } else {

                }

            })

            .collect();

        Ok(repo::Info {

            payloads,

            delegates,

            rid,

            seeding,

        })

        let repo = self.profile.storage.repository(rid)?;

        let doc = repo.identity_doc()?;

        // Don't allow accessing private repos.

            return Err(Error::NotFound);

        }

        Ok((repo, doc))

    Router::new()

        .route("/", get(root_handler))

        .merge(v1::router(ctx))

}

async fn root_handler() -> impl IntoResponse {

    use std::cmp::Ordering;

    use std::collections::BTreeMap;

    use serde::{Deserialize, Serialize};

    use serde_json::json;

    use radicle::identity::doc::{Payload, PayloadId};

    use radicle::identity::RepoId;

    use radicle::node::routing::Store;

    pub struct SearchResult {

        pub rid: RepoId,

        pub payloads: BTreeMap<PayloadId, Payload>,

        pub seeds: usize,

        #[serde(skip)]

        pub index: usize,

    impl SearchResult {

        pub fn new(

            q: &str,

            db: &Database,

            aliases: &Aliases,

        ) -> Option<Self> {

                return None;

            }

            let Ok(Some(index)) = info.doc.project().map(|p| p.name().find(q)) else {

                return None;

            };

            let seeds = db.count(&info.rid).unwrap_or_default();

            Some(SearchResult {

                rid: info.rid,

                delegates,

                seeds,

                index,

    let response = json!({

        "message": "Welcome!",

        "service": "radicle-httpd",

        "apiVersion": API_VERSION,

        "nid": ctx.profile.public_key,

        "path": "/api/v1",

        RepoQuery::All => storage

            .repositories()?

            .into_iter()

            .collect::<Vec<_>>(),

        RepoQuery::Pinned => storage

            .repositories_by_id(pinned.repositories.iter())?

            .into_iter()

            .collect::<Vec<_>>(),

    };

    repos.sort_by_key(|p| p.rid);

        RepoQuery::All => storage

            .repositories()?

            .into_iter()

            .collect::<Vec<_>>(),

        RepoQuery::Pinned => storage

            .repositories_by_id(pinned.repositories.iter())?

            .into_iter()

            .collect::<Vec<_>>(),

    };

    repos.sort_by_key(|p| p.rid);

/// `GET /repos/:rid/remotes`

async fn remotes_handler(State(ctx): State<Context>, Path(rid): Path<RepoId>) -> impl IntoResponse {

    let (repo, doc) = ctx.repo(rid)?;

    let aliases = &ctx.profile.aliases();

    let remotes = repo

        .remotes()?

    Path((rid, node_id)): Path<(RepoId, NodeId)>,

) -> impl IntoResponse {

    let (repo, doc) = ctx.repo(rid)?;

    let remote = repo.remote(&node_id)?;

    let refs = remote

        .refs

    // Don't allow cloning of private repositories.

    let doc = profile.storage.repository(id)?.identity_doc()?;

        return Err(Error::NotFound);

    }

use axum::response::IntoResponse;

use axum::routing::get;

use axum::{middleware, Json, Router};

use tokio::net::TcpListener;

use tower_http::trace::TraceLayer;

use tracing::Span;

use tracing_extra::{tracing_middleware, ColoredStatus, Paint, RequestId, TracingInfo};

mod api;

mod axum_extra;

mod cache;

        .route("/", get(root_index_handler))

        .merge(git_router)

        .nest("/api", api_router)

    Ok(app)

}

async fn root_index_handler() -> impl IntoResponse {

    let response = serde_json::json!({

        "welcome": "Welcome to the radicle-httpd JSON API, this service doesn't serve the Radicle Explorer web client.",

        "path": "/",

        "links": [

            {

use std::sync::Arc;

use axum::extract::{Query, State};

use axum::response::IntoResponse;

use axum::routing::get;

use axum::Router;

use hyper::HeaderMap;

use radicle_surf::blob::{Blob, BlobRef};

use radicle::prelude::RepoId;

use radicle::profile::Profile;

        .route("/:rid/head/*path", get(file_by_canonical_head_handler))

        .route("/:rid/blobs/:oid", get(file_by_oid_handler))

        .with_state(profile)

}

async fn file_by_commit_handler(

    let repo = storage.repository(rid)?;

    // Don't allow downloading raw files for private repos.

        return Err(Error::NotFound);

    }

    let repo = storage.repository(rid)?;

    // Don't allow downloading raw files for private repos.

        return Err(Error::NotFound);

    }

    let repo = storage.repository(rid)?;

    // Don't allow downloading raw files for private repos.

        return Err(Error::NotFound);

    }

use axum::body::{Body, Bytes};

use axum::http::{Method, Request};

use axum::Router;

use serde_json::Value;

use tower::ServiceExt;

use radicle::cob::patch::MergeTarget;

use radicle::crypto::ssh::Keystore;

use radicle::crypto::{KeyPair, Seed, Signer};

use radicle::git::{raw as git2, RefString};

use radicle::identity::{project, Visibility};

use radicle::profile::{env, Home};

use radicle::storage::ReadStorage;

use radicle::{node, profile};

use radicle::{Node, Storage};

use crate::api::Context;

        )

        .unwrap();

    radicle::storage::git::transport::local::register(storage.clone());

    keystore.store(keypair.clone(), "radicle", None).unwrap();

  await page.goto(peer.uiUrl());

  await expect(page.getByText(shortNodeRemote).first()).toBeVisible();

});

test("node repos", async ({ page }) => {

\ No newline at end of file

\ No newline at end of file

\ No newline at end of file

\ No newline at end of file