Vibeleaderboard
Index / tool

terminal-browser

terminal-browser.com
Visit terminal-browser.com
Category
Developer Tools
Rank
Type
TOOL
Use case
Software Testing & Quality
Interfaces
CLI
Latest release
v0.15.2
Date

About

A real, interactive browser that runs inside a terminal pane, letting developers view and control live websites (including on remote servers over SSH) without port forwarding. It ships an agent-compatible CLI so coding agents like Claude Code can open URLs, test flows, and render HTML plans side-by-side with the terminal session.

What it does

It runs a full Chromium instance in a background process and streams its rendered pixels straight into your terminal window, using a graphics protocol some modern terminal emulators support natively. A companion command line process starts that background renderer, attaches your terminal to it as a pane, and forwards your mouse and keyboard input back to the page. Because the browsing itself happens wherever you point the command, aiming it at a site running on another machine over an encrypted shell connection works without configuring any tunnels, and a scriptable command surface lets an automated coding assistant open pages and act on them the same way.

Why it's ranked here

MIT licensing and a clean split into separate command line, renderer, and storage packages make this a real piece of engineering rather than a demo wrapped around someone else's browser view. It talks to Chromium directly through the debugger protocol instead of screen scraping, injects its own page script to let you grab an element and hand it to an agent, and keeps every open session tracked in a local database instead of ad hoc files. That level of plumbing, done for a genuinely underserved workflow, running a live page beside a terminal session, earns the spot more than the idea alone would.

What's good

The element-picker feature is well thought out: it drops a script into the page that listens for a selection, quietly hides its own overlay artifacts, and hands the copied content back to the host process over a debugging channel, which is a more reliable path than clipboard polling. Recording works the same way, capturing frames, clicks, and a pointer trail with an enforced ten-minute ceiling so nothing runs away and fills a disk. Remote use over an encrypted connection is handled by running the browser locally and proxying only network requests through the remote host, not by shipping every frame over the wire, which keeps it responsive.

Tradeoffs

This is a heavy way to get a browser: a full Chromium and Electron install runs behind the scenes for something a plain terminal command usually handles line by line. It only works in terminal emulators that implement a specific pixel graphics protocol, so plenty of setups will not display anything at all. Only macOS and Linux are supported, and the two platforms are not treated identically. Input handling in particular relies on a separate helper process only on macOS, a sign that the terminal-input story is not yet uniform across operating systems.

How to use it well

This earns a place in a workflow where a coding agent needs to see and click through a real, rendered page next to the terminal it is working in, for example verifying a UI change or walking through a flow before calling a task done. It is also a solid pick for previewing a site running on a remote machine without setting up local networking. It is not the right tool for headless testing, continuous integration, or any terminal that cannot display images, where a conventional headless browser library remains the better choice.

Technical notes+

cli/src/main.ts implements the CLI entry point: it computes a build stamp from the compiled browser bundle's modification time, connects to a Unix domain socket daemon (spawning one via a launch helper if none answers), and retries the open handshake when the daemon reports a stale build. browser/src/daemon.ts owns the daemon process itself: a net.createServer JSON-line protocol tracks sessions in a Map, exits after a 15 second idle timer once the last session closes, and refuses to start a second instance against the same socket. browser/src/main.tsx boots the Electron app, disables backgrounding switches, and optionally passes a Chromium remote-debugging port through to browser/src/session/session.tsx, whose Session class wires a TabManager and Registry together and drives the on-screen Chrome UI. browser/src/grab/grab.ts bundles a react-grab preload script executed via webFrame.executeJavaScript in the page's main world, adds a CDP Runtime.addBinding channel (__pixelEmit) to receive selection events, and separately wires an isolated-world listener (COPY_ON_SELECT_WORLD_ID) for copy-on-select. browser/src/record/recorder.ts hard-caps recordings at MAX_RECORDING_MS (10 minutes), tracks frame timing with a binary-search helper (lastIndexAtOrBefore), and listens for Page.loadEventFired over the CDP debugger connection. store/src/schema.ts defines drizzle-orm sqlite-core tables (instances, app_state, settings) exported through store/src/index.ts. cli/src/claude-bridge.ts spawns a 'claude-bridge serve' subprocess exposing a token-authenticated bridge, with zod schemas (PixelMessage, InputEvent) validating the message types crossing it. pnpm-workspace.yaml declares a three-package workspace (browser, cli, store) with better-sqlite3 and an external pixel-rendering package marked as built dependencies; LICENSE is MIT; AGENTS.md (mirrored by CLAUDE.md) sets contributor conventions around comments and backward compatibility.

Observed

License
MIT license
Packaging
TypeScript codebase organized as a pnpm workspace of three packages: browser, cli, and store
Persistence
Persists local session and settings state in SQLite via drizzle-orm
Interfaces
Ships as a standalone CLI plus a token-authenticated local bridge used by an editor and agent plugin integration
Platform
Supports macOS and Linux only, with separate code paths for Chromium sandbox setup on Linux and dock and clipboard behavior on macOS
Structural
Depends on an external library for the terminal graphics and input layer rather than implementing that layer in this repository
Structural
Root package.json defines no test script
Architecture
Renders by driving Chromium through Electron and displaying frames via a terminal graphics protocol supported by a specific set of terminal emulators

Read from README.md, package.json, cli/src/main.ts, browser/src/main.tsx, browser/src/daemon.ts, browser/src/session/session.tsx, browser/src/grab/grab.ts, browser/src/record/recorder.ts, store/src/index.ts, store/src/schema.ts, cli/src/claude-bridge.ts, AGENTS.md, CLAUDE.md, LICENSE, pnpm-workspace.yaml.

What it can do

  • View and control live websites on remote servers over SSH

    SSH session → Browser control without port forwarding

  • Open URLs via CLI commands for coding agents

    URL → Loaded webpage in terminal browser

  • Test website flows through an agent-compatible CLI

    Test steps/commands → Executed browser interactions

  • Render HTML plans alongside the terminal session

    HTML content → Rendered HTML view side-by-side with terminal

Tags

terminalbrowserclisshai-agentsdeveloper-toolsbrowser-automation

Tech Stack

Node.js

Media

terminal-browser

Comments (0)

No comments yet

Editorially curated, with community endorsements as a secondary signal. Corrections welcome.