radicle-cli: Build on Windows — heartwood

This patch contains a number of changes, with the main goal of getting radicle-cli to build on Windows.

In order to achieve this, I removed some features:

The spinner in radicle-term does not react to signals on Windows, of course it still reacts to signals on Unix-like platforms.
In radicle file limits are not set on Windows, the implementation always errors. Of course, file limits are still set on Unix-like platforms.

One feature was added: radicle and radicle-ssh now support not only Unix Domain Socket on Unix-like platforms but also Named Pipes on Windows, via the winpipe crate. The (useless?) implementation for connecting to SSH agents via TCP streams was removed.

Some behaviour was changed in radicle-term so that it does not depend on libc and raw file descriptors (which are only available on Unix-like platforms).

 ]
 [[package]]
 name = "defer-heavy"
 version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5053691e3e6c0e5979cfb55503b7eb4b06531897b5c15b0f617110096b05a0e1"
 [[package]]
 name = "der"
 version = "0.7.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"

  "iana-time-zone-haiku",
  "js-sys",
  "wasm-bindgen",
  "windows-core",
  "windows-core 0.52.0",
 ]
 [[package]]

 [[package]]
 name = "log"
 version = "0.4.21"
 version = "0.4.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c"
 checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
 [[package]]
 name = "maybe-async"

  "tempfile",
  "thiserror 1.0.69",
  "unicode-normalization",
  "winpipe",
 ]
 [[package]]

 name = "radicle-ssh"
 version = "0.9.0"
 dependencies = [
  "byteorder",
  "log",
  "thiserror 1.0.69",
  "winpipe",
  "zeroize",
 ]

  "crossterm 0.29.0",
  "git2",
  "inquire",
  "libc",
  "pretty_assertions",
  "radicle-signals",
  "shlex",
  "tempfile",
  "thiserror 1.0.69",
  "unicode-display-width",

 ]
 [[package]]
 name = "sync-ptr"
 version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2b115b4cc742d11625f50e0e48ab15baf6fa548c2ec33a8d4113711886316a4f"
 [[package]]
 name = "synstructure"
 version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"

 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 [[package]]
 name = "windows"
 version = "0.58.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dd04d41d93c4992d421894c18c8b43496aa748dd4c081bac0dc93eb0489272b6"
 dependencies = [
  "windows-core 0.58.0",
  "windows-targets 0.52.6",
 ]
 [[package]]
 name = "windows-core"
 version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"

 ]
 [[package]]
 name = "winpipe"
 version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1ccf671d62d1bd0c913d9059e69bb4a6b51f7a4c899ab83c62d921e35f206053"
 dependencies = [
  "defer-heavy",
  "log",
  "rand",
  "sync-ptr",
  "windows",
 ]
 [[package]]
 name = "write16"
 version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"

 sqlite = "0.32.0"
 tempfile = "3.3.0"
 thiserror = "1.0"
 winpipe = "0.1.1"
 zeroize = "1.5.7"
 [workspace.lints]

                 path.display()
             );
         }
         Operation::Edit => match term::editor::Editor::new(&path)?.extension("json").edit()? {
             Some(_) => {
                 term::success!("Successfully made changes to the configuration at {path:?}")
         Operation::Edit => {
             let config = std::fs::read_to_string(&path)?;
             match term::editor::Editor::new("Edit configuration", term::editor::Editor::HELP)
                 .editor(term::editor::default_editor_command().as_ref())
                 .extension(".json")
                 .initial(&config)
                 .edit()?
             {
                 Some(edited) => {
                     std::fs::write(&path, edited)?;
                     term::success!("Successfully made changes to the configuration at {path:?}");
                 }
                 None => {
                     term::info!("No changes were made to the configuration at {path:?}")
                 }
             }
             None => term::info!("No changes were made to the configuration at {path:?}"),
         },
         }
     }
     Ok(())

             // If `--edit` is specified, the document can also be edited via a text edit.
             let proposal = if edit {
                 match term::editor::Editor::comment()
                     .extension("json")
                     .initial(serde_json::to_string_pretty(&current.doc)?)?
                     .editor(term::editor::default_editor_command().as_ref())
                     .extension(".json")
                     .initial(&serde_json::to_string_pretty(&current.doc)?)
                     .edit()?
                 {
                     Some(proposal) => serde_json::from_str::<RawDoc>(&proposal)?,

     Format(#[from] std::fmt::Error),
     #[error(transparent)]
     Git(#[from] git::raw::Error),
     #[error("editor error: {0}")]
     Editor(#[from] term::editor::Error),
 }
 #[derive(Debug)]

             writeln!(&mut input, "> {line}")?;
         }
         let output = term::Editor::comment()
             .extension("diff")
             .initial(input)?
             .editor(term::editor::default_editor_command().as_ref())
             .extension(".diff")
             .initial(&input)
             .edit()?;
         if let Some(output) = output {

     let ssh_agent = match ssh::agent::Agent::connect() {
         Ok(c) => term::format::positive(format!(
             "running ({})",
             c.pid().map(|p| p.to_string()).unwrap_or(String::from("?"))
             c.path()
                 .map(|p| p.display().to_string())
                 .unwrap_or(String::from("?"))
         )),
         Err(e) if e.is_not_running() => term::format::yellow(String::from("not running")),
         Err(e) => term::format::negative(format!("error: {e}")),

 use std::io;
 use radicle_term::table::TableOptions;
 use radicle_term::{Table, VStack};

 pub fn get_title_description(
     title: Option<String>,
     description: Option<String>,
 ) -> io::Result<Option<(String, String)>> {
 ) -> Result<Option<(String, String)>, term::patch::Error> {
     term::patch::Message::edit_title_description(title, description, OPEN_MSG)
 }

     Io(#[from] io::Error),
     #[error("invalid utf-8 string")]
     InvalidUtf8,
     #[error("editor error: {0}")]
     Editor(#[from] term::editor::Error),
     #[error("a patch title must be provided")]
     PatchTitleMissing,
 }
 /// The user supplied `Patch` description.

 impl Message {
     /// Get the `Message` as a string according to the method.
     pub fn get(self, help: &str) -> std::io::Result<String> {
     pub fn get(self, help: &str) -> Result<String, term::editor::Error> {
         let comment = match self {
             Message::Edit => {
                 if io::stderr().is_terminal() {
                     term::Editor::comment()
                         .extension("markdown")
                         .initial(help)?
                         .editor(term::editor::default_editor_command().as_ref())
                         .extension(".md")
                         .initial(help)
                         .edit()?
                 } else {
                     Some(help.to_owned())

         title: Option<String>,
         description: Option<String>,
         help: &str,
     ) -> std::io::Result<Option<(String, String)>> {
     ) -> Result<Option<(String, String)>, Error> {
         let mut placeholder = String::new();
         if let Some(title) = title {

     let (title, description) = (title.trim().to_string(), description.trim().to_string());
     if title.is_empty() {
         return Err(io::Error::new(
             io::ErrorKind::InvalidInput,
             "a patch title must be provided",
         )
         .into());
         return Err(Error::PatchTitleMissing);
     }
     Ok((title, description))

 pub fn get_edit_message(
     patch_message: term::patch::Message,
     patch: &cob::patch::Patch,
 ) -> io::Result<(String, String)> {
 ) -> Result<(String, String), Error> {
     let display_msg = edit_display_message(patch.title(), patch.description());
     let patch_message = patch_message.get(&display_msg)?;
     let patch_message = patch_message.replace(PATCH_MSG.trim(), ""); // Delete help message.

     }
     impl ClientStream for DummyStream {
         fn connect<P>(_path: P) -> Result<AgentClient<Self>, Error>
         where
             P: AsRef<std::path::Path> + Send,
         {
             panic!("This function should never be called!")
         }
         fn request(&mut self, buf: &[u8]) -> Result<Buffer, Error> {
             *self.incoming.lock().unwrap() = buf.to_vec();

         ];
         let stream = DummyStream::default();
         let mut agent = AgentClient::connect(stream.clone());
         let mut agent = AgentClient::new(None, stream.clone());
         agent.remove_identity(&pk).unwrap();

 use std::cell::RefCell;
 use std::path::Path;
 pub use radicle_ssh::agent::client::AgentClient;
 pub use radicle_ssh::agent::client::Error;
 pub use radicle_ssh::{self as ssh, agent::client::ClientStream};
 pub use radicle_ssh as ssh;
 pub use ssh::agent::client::{AgentClient, Error};
 use crate::{PublicKey, SecretKey, Signature, Signer, SignerError};
 #[cfg(not(unix))]
 pub use std::net::TcpStream as Stream;
 #[cfg(unix)]
 pub use std::os::unix::net::UnixStream as Stream;
 use super::ExtendedSignature;
 pub struct Agent {
     client: AgentClient<Stream>,
     client: AgentClient,
 }
 impl Agent {
     /// Connect to a running SSH agent.
     pub fn connect() -> Result<Self, ssh::agent::client::Error> {
         Stream::connect_env().map(|client| Self { client })
     pub fn connect() -> Result<Self, Error> {
         Ok(Self {
             client: AgentClient::connect_env()?,
         })
     }
     /// Register a key with the agent.

         AgentSigner::new(self, key)
     }
     pub fn pid(&self) -> Option<u32> {
         self.client.pid()
     pub fn path(&self) -> Option<&Path> {
         self.client.path()
     }
     pub fn request_identities(&mut self) -> Result<Vec<PublicKey>, ssh::agent::client::Error> {

 use std::ops::Deref;
 use std::os::unix::fs::DirBuilderExt;
 use std::path::{Path, PathBuf};
 use std::{fs, io};

             return Err(Error::AlreadyInitialized);
         }
         fs::DirBuilder::new()
             .recursive(true)
             .mode(0o700)
             .create(&self.path)?;
         {
             let mut builder = fs::DirBuilder::new();
             builder.recursive(true);
             #[cfg(unix)]
             {
                 use std::os::unix::fs::DirBuilderExt as _;
                 builder.mode(0o700);
             }
             builder.create(&self.path)?;
         }
         secret.write_openssh_file(&path, ssh_key::LineEnding::default())?;
         public.write_openssh_file(&path.with_extension("pub"))?;

 pub fn run(profile: radicle::Profile) -> Result<(), Error> {
     // Since we're going to be writing user output to `stderr`, make sure the paint
     // module is aware of that.
     cli::Paint::set_terminal(io::stderr());
     cli::Paint::set_terminal(cli::TerminalFile::Stderr);
     let (remote, url): (Option<git::RefString>, Url) = {
         let args = env::args().skip(1).take(2).collect::<Vec<_>>();

 rust-version.workspace = true
 [dependencies]
 byteorder = "1.4"
 log = { workspace = true }
 thiserror = { workspace = true }
 zeroize = { workspace = true }
 [target.'cfg(windows)'.dependencies]
 winpipe = { workspace = true }

 use std::fmt;
 use std::io::{Read, Write};
 use std::ops::DerefMut;
 use std::os::unix::net::UnixStream;
 use std::path::Path;
 use std::str::FromStr;
 use std::path::{Path, PathBuf};
 #[cfg(unix)]
 pub use std::os::unix::net::UnixStream as Stream;
 #[cfg(windows)]
 pub use winpipe::WinStream as Stream;
 use byteorder::{BigEndian, ByteOrder, WriteBytesExt};
 use log::*;
 use thiserror::Error;
 use zeroize::Zeroize as _;

 #[derive(Debug, Error)]
 pub enum Error {
     /// Agent protocol error.
     #[error("Agent protocol error")]
     #[error("SSH agent replied with unexpected data, violating the SSH agent protocol.")]
     AgentProtocolError,
     #[error("Agent failure")]
     #[error(
         "SSH agent replied with failure (protocol message number 5), which could not be handled."
     )]
     AgentFailure,
     #[error("Unable to connect to ssh-agent. The environment variable `SSH_AUTH_SOCK` was set, but it points to a nonexistent file or directory.")]
     BadAuthSock,
     #[error(transparent)]
     #[error("Unable to connect to SSH agent because '{path}' was not found: {source}")]
     BadAuthSock {
         path: String,
         source: std::io::Error,
     },
     #[error("Encoding error while communicating with SSH agent: {0}")]
     Encoding(#[from] encoding::Error),
     #[error("Environment variable `{0}` not found")]
     EnvVar(&'static str),
     #[error(transparent)]
     #[error("Unable to read environment variable '{var}': {source}")]
     EnvVar {
         var: String,
         source: std::env::VarError,
     },
     #[error("Unable to connect SSH agent using the path '{path}': {source}")]
     Connect {
         path: String,
         #[source]
         source: std::io::Error,
     },
     #[error("I/O error while communicating with SSH agent: {0}")]
     Io(#[from] std::io::Error),
     #[error(transparent)]
     Private(Box<dyn std::error::Error + Send + Sync + 'static>),
     #[error(transparent)]
     Public(Box<dyn std::error::Error + Send + Sync + 'static>),
     #[error(transparent)]
     Signature(Box<dyn std::error::Error + Send + Sync + 'static>),
 }
 impl Error {
     pub fn is_not_running(&self) -> bool {
         matches!(self, Self::EnvVar("SSH_AUTH_SOCK"))
         matches!(self, Self::EnvVar { .. } | Self::BadAuthSock { .. })
     }
 }
 /// SSH agent client.
 pub struct AgentClient<S> {
 pub struct AgentClient<S = Stream> {
     /// The path that was originally used to connect to the agent.
     path: Option<PathBuf>,
     /// The underlying stream to the SSH agent.
     stream: S,
 }
 impl<S> AgentClient<S> {
     /// Connect to an SSH agent via the provided stream (on Unix, usually a Unix-domain socket).
     pub fn connect(stream: S) -> Self {
         AgentClient { stream }
     }
     /// Get the agent PID.
     pub fn pid(&self) -> Option<u32> {
         std::env::var("SSH_AGENT_PID")
             .ok()
             .and_then(|v| u32::from_str(&v).ok())
     pub fn path(&self) -> Option<&Path> {
         self.path.as_deref()
     }
 }
 pub trait ClientStream: Sized + Send + Sync {
     /// Send an agent request through the stream and read the response.
     fn request(&mut self, req: &[u8]) -> Result<Buffer, Error>;
     /// How to connect the streaming socket
     fn connect<P>(path: P) -> Result<AgentClient<Self>, Error>
 impl AgentClient<Stream> {
     /// Connect to an SSH agent at the provided path.
     pub fn connect<P>(path: P) -> Result<Self, Error>
     where
         P: AsRef<Path> + Send;
     fn connect_env() -> Result<AgentClient<Self>, Error> {
         let Ok(var) = std::env::var("SSH_AUTH_SOCK") else {
             return Err(Error::EnvVar("SSH_AUTH_SOCK"));
         P: AsRef<Path>,
     {
         let path = path.as_ref().to_owned();
         let stream = match Stream::connect(&path) {
             Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
                 return Err(Error::BadAuthSock {
                     path: path.display().to_string(),
                     source: err,
                 })
             }
             Err(err) => {
                 return Err(Error::Connect {
                     path: path.display().to_string(),
                     source: err,
                 })
             }
             Ok(stream) => stream,
         };
         match Self::connect(var) {
             Err(Error::Io(io_err)) if io_err.kind() == std::io::ErrorKind::NotFound => {
                 Err(Error::BadAuthSock)
         Ok(Self {
             path: Some(path),
             stream,
         })
     }
     pub fn connect_env() -> Result<Self, Error> {
         const SSH_AUTH_SOCK: &str = "SSH_AUTH_SOCK";
         let path = match std::env::var(SSH_AUTH_SOCK) {
             Ok(var) => var,
             Err(err) => {
                 if cfg!(windows) {
                     // Windows uses a named pipe for the SSH agent, which
                     // we fall back to in case reading the environment
                     // variable fails.
                     "\\\\.\\pipe\\openssh-ssh-agent".to_string()
                 } else {
                     return Err(Error::EnvVar {
                         var: SSH_AUTH_SOCK.to_string(),
                         source: err,
                     });
                 }
             }
             other => other,
         }
         };
         Self::connect(path)
     }
 }
 impl<S: ClientStream> AgentClient<S> {
 impl<Stream: ClientStream> AgentClient<Stream> {
     pub fn new(path: Option<PathBuf>, stream: Stream) -> Self {
         Self { path, stream }
     }
     /// Send a key to the agent, with a (possibly empty) slice of constraints
     /// to apply when using the key to sign.
     pub fn add_identity<K>(&mut self, key: &K, constraints: &[Constraint]) -> Result<(), Error>

                 match *cons {
                     Constraint::KeyLifetime { seconds } => {
                         buf.push(msg::CONSTRAIN_LIFETIME);
                         buf.deref_mut().write_u32::<BigEndian>(seconds)?
                         buf.extend_u32(seconds);
                     }
                     Constraint::Confirm => buf.push(msg::CONSTRAIN_CONFIRM),
                     Constraint::Extensions {

         let total = 1 + pk.len() + 4 + data.len() + 4;
         let mut buf = Buffer::default();
         buf.write_u32::<BigEndian>(total as u32)
             .expect("Writing to a vector never fails");
         buf.extend_usize(total);
         buf.push(msg::SIGN_REQUEST);
         buf.extend_from_slice(&pk);
         buf.extend_ssh_string(data);
         // Signature flags should be zero for ed25519.
         buf.write_u32::<BigEndian>(0).unwrap();
         buf.extend_u32(0);
         buf
     }

     }
 }
 #[cfg(not(unix))]
 impl ClientStream for TcpStream {
     fn connect_uds<P>(_: P) -> Result<AgentClient<Self>, Error>
     where
         P: AsRef<Path> + Send,
     {
         Err(Error::AgentFailure)
     }
     fn read_response(&mut self, _: &mut Buffer) -> Result<(), Error> {
         Err(Error::AgentFailure)
     }
     fn connect_env() -> Result<AgentClient<Self>, Error> {
         Err(Error::AgentFailure)
     }
 pub trait ClientStream: Sized + Send + Sync {
     fn request(&mut self, msg: &[u8]) -> Result<Buffer, Error>;
 }
 #[cfg(unix)]
 impl ClientStream for UnixStream {
     fn connect<P>(path: P) -> Result<AgentClient<Self>, Error>
     where
         P: AsRef<Path> + Send,
     {
         let stream = UnixStream::connect(path)?;
         Ok(AgentClient { stream })
     }
 impl<S: Read + Write + Sized + Send + Sync> ClientStream for S {
     fn request(&mut self, msg: &[u8]) -> Result<Buffer, Error> {
         let mut resp = Buffer::default();