Terminalwire streams a command-line interface from your web app's server. No binaries to build, no client SDKs to maintain, no separate repo. That means your team spends time building features, not fighting infrastructure.
Users paste one prompt into Claude or Codex. The agent installs your CLI, runs your onboarding flow, and they're set up. No docs to read, no steps to follow.
Add two gems, run a generator, deploy. Your CLI updates the moment you push code. No binaries to rebuild, no releases to cut, no update prompts for users.
MCP requires a custom server that only agents can talk to. A CLI works with every AI agent out of the box and humans can run it too. One interface, two audiences.
Command-line interfaces have been around for 50 years. Every AI agent already knows how to run shell commands. Build your integration on something that lasts.
Terminalwire sandboxes every connection. Servers can only access stdio and a scoped storage path—file system, environment variables, and browser access require explicit entitlements.
No need to hire CLI specialists or learn a new language. Your web developers build commands with the same sessions, authentication, and routing patterns they already use. Same codebase, same deploy, same team.
It does things SSH can’t, like launch web browsers so users can login via Google OAuth or Okta, store cookies on your users workstations, manage files, and more.
This is how a Rails developer installs Terminalwire on their app server.
Installs the Terminalwire Server
bundle add terminalwire-rails
Generates starter command-line app files
bin/rails g terminalwire:install
It generates the files needed to build command-line apps.
This is the code a Rails developer customizes and deploys to production.
# Code a Rails developer writes to build a # Terminalwire command-line app class ApplicationTerminal < Thor # Stream Thor from the server to the Terminalwire client include Terminalwire::Thor desc "open", "Opens blog post in web browser" def open(id) # Open browser to post on their browser.open post_url(id) end desc "posts BLOG_ID", "Lists posts for a given blog" def posts(blog_id = nil) # Print's a table to stdio on the client table do |t| t.header "Title", "Status" current_user.posts.where(blog_id:).each do t.row it.title, it.status end end end end
Notice what’s missing? APIs, client-code, integration tests, cross-platform binaries, a CI that builds everything, a seperate repo with the CLI app implemented in a different language, and a whole lot of complicated plumbing.
Terminalwire streams commands like puts, gets, browser.open, File.read, and more from the server to the client. It’s like a web browser, but for command-line apps.
Terminalwire makes installation a one-step process for you and your users with the one-line curl installer.
Installs `my-app` app on macOS or Linux
curl -Ls https://my-app.terminalwire.sh | bash
The installer handles all of this stuff so you don’t have to:
$PATH variable automatically so users can run my-app from their terminal.my-app command-line app, which points to your server.Once installed, users run your app like any other terminal app: type in the command my-app and hit enter.
Users run your command-line app like any other terminal app
my-app
Commands:
my-app help [COMMAND] # Describe available commands or one specific command
my-app open # Opens blog post in web browser
my-app posts # Lists posts for a blog
my-app version # Prints the version of the CLI
The only difference is the command was sent to your server, processed, then streamed back to the client.
Know what’s in the my-app binary that your users install? Not much. Just these two lines of text.
#!/usr/bin/env terminalwire-exec url: "https://example.com/terminal"
This is how your app is kept-up-to-date. When your users enter a command like my-app posts, is streams that to your server, in this case https://example.com/terminal. The server parses the command, executes it, streams the output back to the client, and that’s it.
In a lot of ways it works like a web browser, but with a completely different protocol that’s designed for command-line apps.
TRMNL had to fulfill 1,325 Kickstarter orders for a WiFi-enabled e-Ink display and a developer-friendly SDK for custom visualizations. With Terminalwire, they shipped a polished developer experience to their users in a matter of days.
Read how Terminalwire helped TRMNL →Don't see your framework? Talk to a human and we'll get you up and running.
No. Terminalwire runs on your server. Your users’ CLI connects directly to your infrastructure over an encrypted connection. We never see your data.
The only thing that touches Terminalwire.com is a license check: the client sends the server URL to verify it’s licensed, caches the result for 24 hours, and moves on. If our license server is down, the client connects anyway.
Terminalwire is a WebSocket-based protocol that streams standard I/O, and other channels, between a web server and client. This allows you to use your preferred command-line parser within your favorite web server framework to deliver a delightful CLI experience to your users.
Free Terminalwire licenses are available personal use and commercial Terminalwire licenses are available for organizations depending on revenue, gross assets, and features. Detailed information on pricing, features, and requirements may be found on the licensing page.
Terminalwire integrates with your existing web app’s authentication and authorization mechanisms. You can use the same authentication and authorization methods you use for your web app.
Yes! Terminalwire is designed to be integrated with any web framework and server that supports WebSockets.
Yup. Terminalwire uses the same TLS encryption as your web server and browser, which is WebSockets Secure (WSS) in a production web environment.
SSH was created in 1995 to secure, encrypted interactive remote shell sessions. It includes features not needed by modern command-line apps for web applications, such as file transfer, port forwarding, and public-key authentication. Today’s command-line applications for web apps need to do things SSH can’t, like open a web browser on the client to authenticate via the web application.
Terminalwire was built specifically to solve problems that modern command-line web apps demand that SSH can’t. It’s a WebSocket-based protocol that streams standard I/O, and other channels, between a web server and client. This allows you to use your preferred command-line parser within your favorite web server framework to deliver a delightful CLI experience to your users.
You can, and it’ll work great for a demo. But the moment real users depend on it, you’re maintaining two codebases, two deploy pipelines, two sets of tests, and a release process for cross-platform binaries. Auth gets reinvented from scratch, updates require users to download new builds, and there’s no security sandbox protecting their workstations. Terminalwire handles all of that so your team stays focused on the commands that matter to your customers.