A configured zsh is more than a shell — it is a stack: .zshrc, oh-my-zsh, the theme you tuned, plugins like zsh-autosuggestions and zsh-syntax-highlighting, and years of shared history. All of that lives on the machine where zsh runs, which makes a fresh SSH login from a phone a poor substitute: plugins load, but the session is new, the scrollback is empty, and it dies with the connection. CLIAnywhere attaches the phone to the zsh session that already runs on your PC, so the theme, the plugins and the history are simply there — and there is nothing to install or configure on the phone at all.
Short Answer
Run the CLIAnywhere daemon on the machine that hosts your zsh setup (Linux or macOS — or Windows with your preferred shell), install the app on your phone or use the web client, and pair once with an access key. The phone then opens the persistent zsh session running on your PC: oh-my-zsh and its plugins are loaded because the shell sourced your .zshrc from your home directory, and the session survives every disconnect, keeping its scrollback and its running jobs until you come back — from the phone, the web client, or the desktop.
Why This Is Difficult
zsh configurations are deeply host-local. The .zshrc may set ZSH to an oh-my-zsh checkout under $HOME, enable a list of plugins, and load a prompt theme that shells out to git to build each prompt line. Interactive behavior comes from ZLE, the zsh line editor, whose widgets — incremental history search, the autosuggestion ghost text, syntax highlighting as you type — are bound to key sequences and run inside the shell process. None of this is a file you can "open" remotely; it is a live process.
That makes the naive approaches miss the point. A new SSH login from a phone gives you a new zsh: it will re-read .zshrc and reload plugins, but the session at your desk — its current directory, exported variables, running jobs, and scrollback — is a different process. Reconnect after the mobile link drops and you get yet another one. You can mitigate with SHARE_HISTORY and a multiplexer, but you are still rebuilding around the session instead of rejoining it.
Syncing the config elsewhere does not help either. Dotfile repos and tools like chezmoi replicate your .zshrc to other machines — useful when you genuinely want a second machine configured — but they copy the configuration, not the session. What mobile use actually needs is for the session to be owned by the host and viewed by the phone, which is precisely CLIAnywhere's model.
Common Solutions
Option 1: A mobile SSH client
Every mobile platform has SSH apps, and they do connect to a zsh on the host — plugins load, the theme renders. The cost is everything around the moment of typing: the host must run a reachable SSH server (port forwarding or a public address), keys must live on the phone, and each login is a fresh shell that ends with the connection, taking its scrollback and jobs with it.
zsh-specific friction shows up in ZLE: widgets bound to keys like Ctrl+R or Esc-sequences assume a physical keyboard, and touch keyboards approximate them awkwardly.
Option 2: zsh inside tmux, over SSH
Wrapping zsh in tmux on the host gives the session a lifetime independent of the connection: tmux attach from the next login returns you to the same shell, plugins, and scrollback. Combined with SHARE_HISTORY in .zshrc, history converges between the desk and the phone too.
The remaining weight is operational: SSH reachability from wherever you happen to be, key management on the phone, and driving tmux's prefix keys plus ZLE key bindings from a touch screen. It works — many people run exactly this stack — but it is three layers deep for what should be one tap.
Best for: experienced SSH+tmux users who already have the pipeline memorizedOption 3: Dotfiles synced to another machine
Keeping your zsh config in a dotfiles repository (or managed with chezmoi) means any machine can have your prompt and plugins after a clone and a restart of the shell. This solves portability of the setup, which matters if you genuinely work on several machines.
It does not give you your session: a zsh on a synced laptop is still a different process, with different history timing, no access to the original machine's files, and no view of jobs running there. For "use the computer I was just using, from my phone", syncing config answers a different question.
Best for: keeping multiple machines configured identicallyOption 4: CLIAnywhere
With CLIAnywhere, the zsh session is hosted by the daemon on your PC and every client attaches to it. The shell that renders your prompt, runs your widgets and writes your history is one process on one machine — your machine. The phone contributes input and a display; it never needs oh-my-zsh, your theme, or any shell at all installed.
Because the session outlives any single connection, you can start a command at the desk, walk out, and pick it up from the phone with the scrollback intact — the workflow dotfile syncing and fresh SSH logins cannot offer. The connection needs no SSH server, no port forwarding and no public IP: peer-to-peer over DTLS where possible, encrypted relay as fallback.
Best for: using your tuned zsh from a phone with zero mobile-side setupUsing CLIAnywhere
Install the daemon on the machine with your zsh setup
Install the open-source daemon from GitHub Releases on the Linux or macOS machine where your .zshrc lives (a headless CLI build exists for Linux servers — see the Linux platform guide). Platform-by-platform instructions are in the setup guide. On the phone: Android on Google Play, iOS on the App Store (see the download page), or the Web App.
Pair the app with your PC
Generate an access key in the app and link it to the daemon by pasting it or scanning the daemon's QR code. Pairing is a local SPAKE2 key exchange — the Security Code is generated on the PC and never uploaded. One account can hold several PCs, each with its own code.
Open the session — your zsh, already configured
Tap the PC in the app. The session that opens is zsh on your machine: oh-my-zsh plugins loaded from your .zshrc, your prompt theme, your SHARE_HISTORY setting, your z directory jumps. Type git status or a long docker compose up, lock the phone whenever you like, and reopen the same session later from any client — the shell never restarted.
| zsh as a supported shell | Yes — alongside bash, fish, sh, cmd, pwsh, powershell |
|---|---|
| oh-my-zsh / plugins / theme on the host | Yes — shell reads your .zshrc on the PC |
| Anything to configure on the phone | No |
| History shared across phone and desktop | Yes — one ~/.zsh_history on the host |
| Session and scrollback survive disconnects | Yes |
| Linux / macOS host (Windows too) | Yes (Linux: desktop UI or headless CLI build) |
| iOS / Android / Web client | Yes — see the download page |
| SSH server, port forwarding or public IP required | No |
| Encryption | SPAKE2 key exchange + AES-256-GCM, P2P (DTLS) with encrypted relay (WSS) fallback |
| Open-source daemon | Yes — github.com/CLIAnywhere/clianywhere_daemon |
Example: Debugging a Container With Muscle Memory
Your zsh is tuned for container work: oh-my-zsh with the docker plugin and its aliases, zsh-autosuggestions so long commands ghost-complete from history, and a two-line prompt showing the git branch and the Kubernetes context. At your desk, kubectl logs -f deploy/api is half-typed before you finish thinking it.
At 17:40 the deploy is misbehaving and you have to leave. You open CLIAnywhere on your phone and tap the PC: the same zsh session is there, in the same directory, with the kubectl logs you ran an hour ago still in scrollback. You scroll up, compare the two stack traces, and type kubectl — the autosuggestion completes the rest of the command you ran yesterday, because the suggestion engine is running on the PC with your full history.
The fix needs a config edit and a restart. You reopen the file with the same command from history, change one line, and run the restart — from a bus stop, on cellular. The prompt's Kubernetes context updates after the restart exactly as it would at the desk, because the widget that renders it runs on the host. Tomorrow morning the desktop session is where you left it, history complete. None of this required installing oh-my-zsh anywhere but on your PC.
Security
Attaching a phone to your zsh session is protected end to end: keys are negotiated locally with SPAKE2 (the Security Code is generated on your PC and never uploaded), traffic is AES-256-GCM encrypted, the link is peer-to-peer over DTLS where possible, and the relay sees only ciphertext. No inbound port is opened on the host. See how CLIAnywhere handles security for details.