# Dosh

Dosh is an encrypted remote terminal for fast reconnecting shells. It is meant
to replace Mosh and day-to-day interactive SSH sessions.

It runs a `dosh-server` on the remote machine and a `dosh` client locally. The
first setup can use SSH. After that, Dosh can attach over encrypted UDP with
cached credentials, keep terminal sessions alive, reconnect after network
changes, and forward TCP ports.
It also includes native encrypted file copy over the Dosh stream layer.

## Support

- Client: macOS, Linux, Windows
- Server: Unix-like systems with PTYs
- Windows: client only
- UDP port: one configured server port, default `50000`

Dosh does not implement SFTP, X11 forwarding, or a Windows server. Windows is
client-only.

## Install

Server and client on Unix/macOS:

```sh
curl -fsSL https://git.palav.dev/Palav/dosh/raw/branch/main/install.sh | sh -s -- both --repo https://git.palav.dev/Palav/dosh.git --port 50000
```

Client only on Unix/macOS:

```sh
curl -fsSL https://git.palav.dev/Palav/dosh/raw/branch/main/install.sh | sh -s -- client --repo https://git.palav.dev/Palav/dosh.git
```

Windows client:

```powershell
irm https://git.palav.dev/Palav/dosh/raw/branch/main/install.ps1 | iex
```

## Commands

```sh
dosh setup HOST          # import SSH config and trust the Dosh host key
dosh HOST                # connect
dosh HOST COMMAND        # connect and run a command
dosh exec HOST COMMAND   # run a non-interactive remote command
dosh cp SRC DST          # copy files; use host:path for a remote side
dosh ls host:path        # list a remote path
dosh cat host:path       # print a remote file
dosh mkdir host:path     # create a remote directory
dosh rm [-r] host:path   # remove a remote file or directory
dosh update              # update Dosh
dosh status HOST         # show remote tmux sessions and Dosh service status
dosh restart HOST        # restart dosh-server and show service status
dosh doctor HOST         # check config and connectivity
dosh recover HOST        # clear cached attach state and re-check
dosh proxy-stdio HOST 127.0.0.1 22
dosh vscode HOST [PATH]  # configure/open VS Code Remote-SSH through Dosh
```

Examples:

```sh
dosh server
dosh server tm
dosh exec server 'uname -a'
dosh cp file.txt server:tmp/file.txt
dosh cp -r server:Projects/app ./app
dosh cp -r server:Projects/app backup:app
dosh ls server:Projects
dosh cat server:tmp/file.txt
dosh forward server -L 8080:127.0.0.1:80
dosh forward server -D 1080
dosh forward server -R 2222:127.0.0.1:22
dosh proxy-stdio server 127.0.0.1 22
dosh vscode server /home/me/project
```

Agent forwarding is opt-in with `-A` and must be enabled on the server.
File copy is enabled by `allow_file_transfer = true` on the server.

## VS Code

Dosh can carry VS Code Remote-SSH without replacing VS Code's SSH workflow.

```sh
dosh vscode setup server
dosh vscode server /home/me/project
```

This writes a managed SSH config entry using:

```sshconfig
ProxyCommand dosh proxy-stdio server %h %p
```

VS Code still uses Remote-SSH and the normal remote VS Code Server. Dosh carries
the SSH byte stream over its encrypted reconnecting transport.

The optional extension in `vscode-extension/` provides the same setup from the
Command Palette.

## Library

Dosh can also be used as a Rust transport for application protocols that need
encrypted streams, roaming, reconnect behavior, keepalives, retransmission,
flow control, and in-order delivery.

Use `dosh::client::DoshClient` and `dosh::server::DoshServer` for the complete
native-auth path. Use `dosh::transport::DoshTransport` or `StreamMux` only when
you already have your own session/auth layer.

Client-side SDK:

```rust
let client = dosh::client::DoshClient::load()?;
let mut dosh = client
    .connect("server")
    .service("myapp")
    .connect()
    .await?
    .into_transport();

let stream = dosh.open_service("myapp").await?;
dosh.send(stream, b"hello").await?;
```

Server-side SDK:

```rust
let config = dosh::server::DoshServerConfig::default()
    .service("myapp")?;
let mut server = dosh::server::DoshServer::bind(config).await?;

loop {
    match server.recv().await? {
        dosh::server::DoshServerEvent::Accepted(client) => {
            eprintln!("accepted {:?}", client.conn_id);
        }
        dosh::server::DoshServerEvent::Session { conn_id, event } => {
            if let dosh::transport::SessionEvent::Stream(
                dosh::transport::TransportEvent::Open(open)
            ) = event {
                server.accept_stream(conn_id, open.stream_id).await?;
            }
        }
        dosh::server::DoshServerEvent::Ignored => {}
    }
}
```

The server runtime owns UDP reads and demuxes packets by connection id, so
multiple clients can share one Dosh port without per-session readers racing.

Runnable SDK examples live in `examples/sdk_echo_server.rs` and
`examples/sdk_echo_client.rs`.

## Config

```text
~/.config/dosh/client.toml
~/.config/dosh/hosts.toml
~/.config/dosh/server.toml
```

Common client settings:

```toml
default_session = "new"
auth_preference = "native,ssh"
predict = true
cache_attach_tickets = true
disconnect_status = true
```