Ever Terminal

ever-terminal is designed to be used with the Even App.

Supports macOS, Linux, Windows.

Requirements

• Node.js 22+ — check with node --version. Install from nodejs.org, or brew install node (macOS), or your distro's package manager (Linux).
• An Even Realities G2 + R1 ring, paired through the Even app (iOS/Android).
• Optional but recommended: a Tailscale account signed in on both your laptop and phone — gives you a stable private network without needing the public-tunnel providers below.

Install

npm install -g ever-terminal

Verify the install:

ever-terminal --version

Update to the latest release:

npm install -g ever-terminal@latest

Quick Start

ever-terminal

By default the server starts on http://localhost:3456.

Useful startup options:

ever-terminal --cwd /path/to/project
ever-terminal --port 8080
ever-terminal --token mytoken123
ever-terminal --name my-laptop
ever-terminal --provider codex
ever-terminal --model claude-opus-4-8
ever-terminal --yolo
ever-terminal --expose pinggy
ever-terminal --expose bore
ever-terminal --expose ngrok

How it works

ever-terminal runs a local HTTP server on :3456 (configurable via --port), spawns your AI agent (Claude Code or Codex) as a child process, captures its streaming output, renders it onto the G2's 576×288 canvas, and translates R1 ring gestures back into keyboard events for the agent.

The Even app connects to your laptop over your chosen transport. By default it binds to your detected LAN address (same Wi-Fi). Pass --tailscale to bind on your Tailscale tailnet instead (stable across networks, end-to-end WireGuard), -i <interface> to pin a specific network interface, or --expose pinggy / --expose bore / --expose ngrok to open a temporary public tunnel.

                       ┌──────────────────┐
                       │   your laptop    │
   [ claude / codex ] ─│   ever-terminal  │
                       │   :3456          │
                       └────────┬─────────┘
                                │
                ┌───────────────┴───────────────┐
                │   transport (pick one)        │
                │   default: LAN (same Wi-Fi)   │
                │   --tailscale                 │
                │   --expose pinggy             │
                │   --expose bore               │
                │   --expose ngrok              │
                └───────────────┬───────────────┘
                                │
                       ┌────────┴─────────┐
                       │     Even app     │
                       └──┬────────────┬──┘
                       (display)     (input)
                       BLE ↓          ↑ BLE
                     ┌────┴────┐  ┌────┴────┐
                     │   G2    │  │   R1    │
                     │ 576×288 │  │  ring   │
                     └─────────┘  └─────────┘

The agent is your binary running on your laptop. ever-terminal is a renderer + input bridge, not a runtime.

CLI

ever-terminal [command] [options]

Commands:
  ever-terminal start
  ever-terminal complete <shell>

Local network options:
  --tailscale
  -i, --interface, --if <name>

Quick public expose options:
  --expose <provider>   Quick public expose provider (`pinggy`, `bore`, `ngrok`)

Options:
  -p, --port <n>       Server port (default: 3456)
  -t, --token <str>    Auth token (default: auto-generated)
  -n, --name <str>     Client display name
  -d, --cwd <path>     Project directory (where Claude Code sessions live)
  --global             List sessions across all projects (default: current dir)
  --provider <name>    Default AI provider: claude, codex (default: claude)
  -m, --model <str>    Claude model (default: claude-opus-4-8)
  --effort <level>     Claude effort level: low, medium, high, xhigh, max (default: high)
  --ultracode          Enable ultracode: xhigh effort + dynamic-workflow orchestration (Opus 4.8)
  --suggest            Emit a suggested next prompt after each turn (shown as a notification)
  --log-file [path]    Tee all logs to a file (default: ./ever-terminal-<ts>.log)
  --verbose            Print raw SDK messages for debugging
  --yolo               Skip ALL permission prompts — auto-approve every tool call (dangerous)
  -h, --help
  -v, --version

Examples:
  ever-terminal
  ever-terminal -p 8080
  ever-terminal -t mytoken123
  ever-terminal -m claude-opus-4-8
  ever-terminal --yolo
  ever-terminal --expose pinggy
  ever-terminal --expose ngrok

Quick public expose helpers are intended for simple temporary sharing, not long-term use. For stable setups, prefer a proper network path such as Tailscale or a production tunnel configuration.

Current quick expose providers:

pinggy

No install required — uses your system's SSH client. Just pass --expose pinggy.

Behind the scenes:

ssh -p 443 -R0:localhost:<port> a.pinggy.io

Pinggy is a hosted SSH-tunnel service; the public URL appears in your terminal once the tunnel is up.

bore

Self-hostable, written in Rust. GitHub: ekzhang/bore.

Install:

• macOS: brew install bore-cli (or) cargo install bore-cli
• Linux: cargo install bore-cli (or) download a prebuilt binary from releases and put bore on your $PATH
• Windows: download bore-vX.Y.Z-x86_64-pc-windows-msvc.zip from releases, extract bore.exe, add its folder to your PATH

Verify with bore --version. Then --expose bore runs:

bore local <port> --to bore.pub

ngrok

Hosted tunnel service, free tier available. Site: ngrok.com.

Install:

• macOS: brew install ngrok/ngrok/ngrok
• Linux: see the apt/yum repos at ngrok.com/download — or download the tarball, extract, and put ngrok on your $PATH
• Windows: download the zip from ngrok.com/download, extract ngrok.exe, add its folder to your PATH

One-time setup — sign up at ngrok.com, copy your authtoken from the dashboard, then:

ngrok config add-authtoken <your-token>

Verify with ngrok --version. Then --expose ngrok runs:

ngrok http <port>

--yolo (skip permission prompts)

By default, tool calls that aren't known-safe (writing files, running shell commands, MCP tools) pause and ask for approval on the glasses. --yolo auto-approves every prompt for both providers, so an agent can run unattended:

ever-terminal --yolo

Equivalent via environment variable:

EVER_YOLO=1 ever-terminal

This auto-approves arbitrary shell commands and file writes — only use it on projects you trust. Read-only tools are always auto-approved regardless of this flag.

Shell completion (example usage):

ever-terminal complete zsh
ever-terminal complete bash
ever-terminal complete fish
ever-terminal complete powershell

Each form prints the completion script for that shell.

Flow

1. Start the server with ever-terminal. It prints a connection URL, a token, and a QR code in the terminal.
2. Open the Even app on your phone and scan the QR code — or paste the URL and token manually if scanning isn't convenient.
3. Your G2 glasses and R1 ring connect via BLE through the Even app. The agent's output streams onto the glasses, and ring gestures route back to the agent as keyboard events.

Providers

The server can drive all supported providers concurrently; --provider <name> just chooses the default. Each provider wraps its own CLI — make sure the binary is installed and authenticated beforehand.

| Provider | Required CLI | Auth | Override path env | |------------|-----------------|--------------------------------|--------------------| | claude | claude | claude login (Claude Code) | n/a | | codex | codex | codex first-run wizard | n/a |

Common problems

| Symptom | Cause | Fix | |-----------------------------------------------------------|---------------------------------------------------------|------------------------------------------------------------------------------------------| | Phone app shows "Server unreachable" | Laptop and phone on different transports | Match: both on Tailscale (--tailscale) or both on the same Wi-Fi | | EADDRINUSE :3456 | Another ever-terminal already running | lsof -i :3456 → kill old one, or pass --port <other> | | command not found: claude or codex | Agent binary not on $PATH | Install per the Providers table; verify with which claude / which codex | | --expose pinggy hangs | Pinggy edge timing out | Switch to --expose bore, --expose ngrok, or Tailscale | | Token rotates every restart | Not passing --token | ever-terminal --token my-fixed-token | | Output truncated mid-stream | Agent printed something the 576×288 layout can't render | Re-run with --verbose --log-file ./debug.log and open an issue with the offending line |

For anything else: ever-terminal --verbose --log-file ./debug.log, reproduce, attach the log to an email to [email protected] .

Changelog

Releases are automated via semantic-release — see the version history on npm.

License

MIT