use std::borrow::Cow;

    addr: &'a str,

    port: u16,
    user: Cow<'a, str>,

    addr: String,
    resolved: std::net::SocketAddr,

    config: thrussh_config::Config,

    let user = if let Some(u) = cap.name("user") {
        Cow::Borrowed(u.as_str())
    } else {
        Cow::Owned(whoami::username())
    };

    let port: u16 = cap
        .name("port")
        .map(|x| x.as_str().parse().unwrap())
        .unwrap_or(22);
    let path = cap.name("path").unwrap().as_str();
    let addr = format!("{}:{}", host, port);
    use std::net::ToSocketAddrs;
    if let Ok(mut res) = addr.to_socket_addrs() {
        let resolved = res.next().unwrap();
        Some(Remote {
            host,
            port,
            user,
            path,
            addr,
            resolved,
        })
    } else {
        None

    let mut config =
        thrussh_config::parse_home(&host).unwrap_or(thrussh_config::Config::default(host));
    if let Some(port) = cap.name("port").map(|x| x.as_str().parse().unwrap()) {
        config.port = port
    }
    if let Some(u) = cap.name("user") {
        config.user.clear();
        config.user.push_str(u.as_str());

    let path = cap.name("path").unwrap().as_str();
    Some(Remote {
        addr,
        host,
        path,
        config,
    })

    pub async fn connect(&self, name: &str, channel: &str) -> Result<Ssh, anyhow::Error> {

    pub async fn connect(&mut self, name: &str, channel: &str) -> Result<Ssh, anyhow::Error> {

            addr: self.addr.clone(),

            addr: self.config.host_name.clone(),

        let stream = self.config.stream().await?;

        use std::net::ToSocketAddrs;
        debug!("client: {:?}", client.addr);
        let addr = client.addr.to_socket_addrs()?.next().unwrap();
        let mut h = thrussh::client::connect(config, &addr, client).await?;

        let mut h = thrussh::client::connect_stream(config, stream, client).await?;

        let authenticated = self.auth_agent(&mut h).await.unwrap_or(false)

        let authenticated = self
            .auth_agent(&mut h, &mut key_path)
            .await
            .unwrap_or(false)

    async fn auth_agent(&self, h: &mut thrussh::client::Handle) -> Result<bool, anyhow::Error> {

    async fn auth_agent(
        &self,
        h: &mut thrussh::client::Handle,
        key_path: &mut PathBuf,
    ) -> Result<bool, anyhow::Error> {

        let identities = agent.request_identities().await?;

        let identities = if let Some(ref file) = self.config.identity_file {
            key_path.push(file);
            key_path.set_extension("pub");
            let k = thrussh_keys::load_public_key(&key_path);
            key_path.pop();
            if let Ok(k) = k {
                vec![k]
            } else {
                return Ok(false);
            }
        } else {
            agent.request_identities().await?
        };

                match h.authenticate_future(self.user.as_ref(), key, a).await {

                match h.authenticate_future(&self.config.user, key, a).await {

        for k in &["id_ed25519", "id_rsa"] {

        let mut keys = Vec::new();
        if let Some(ref file) = self.config.identity_file {
            keys.push(file.as_str())
        } else {
            keys.push("id_ed25519");
            keys.push("id_rsa");
        }
        for k in keys.iter() {

                .authenticate_publickey(self.user.as_ref(), Arc::new(k))

                .authenticate_publickey(&self.config.user, Arc::new(k))

            self.user, self.host

            self.config.user, self.config.host_name

        h.authenticate_password(self.user.to_string(), &pass).await

        h.authenticate_password(self.config.user.to_string(), &pass)
            .await

    }
    fn channel_eof(
        self,
        _channel: thrussh::ChannelId,
        session: thrussh::client::Session,
    ) -> Self::FutureUnit {
        Box::pin(async move {
            *self.state.lock().await = State::None;
            Ok((self, session))
        })

        debug!("extended data {:?}, {:?}", std::str::from_utf8(data), ext);

            let mut stderr = std::io::stderr();
            let result = stderr.write_all(data);

            let stderr = std::io::stderr();
            let mut handle = stderr.lock();
            let result = handle.write_all(data);

        if c.is_empty() {
            return Ok(());
        }

        return if let Some(ssh) = ssh_remote(name) {

        return if let Some(mut ssh) = ssh_remote(name) {

    if let Some(ssh) = ssh_remote(name) {

    if let Some(mut ssh) = ssh_remote(name) {

thrussh = "0.29.13"

thrussh = "0.29.15"

thrussh-config = "0.4"