Termexo

One window for every coding agent

English · 简体中文

Website · Download · npm

Termexo puts Claude Code, Codex, and the terminals around them into one recoverable Windows workspace. Keep several agents visible at once, see immediately when one needs input or approval, reopen yesterday's native session, and switch the Claude CLI between compatible model providers without rebuilding your setup.

Run the complete Windows app with one command—no Termexo account or server required:

npx termexo@latest

The current version is V0.7.0. The window drops the system title bar for chrome of its own, with the top bar spanning the width and both side panels beneath it; terminals render on the GPU so a long scrollback scrolls smoothly; a terminal keeps its account across reconnects and restarts; and configuration, plugins, and skills can be copied between accounts without moving any credentials.

_{Claude Code and Codex terminals side by side in a workspace that remembers its layout.}

Four agents. One screen. Run Claude Code, Codex, and OpenCode side by side in as many real PTY terminals as you need, choose which stay visible, and arrange them in a custom 1–6 row/column grid. Reorder tabs by dragging, close one with the middle mouse button, and drive the workbench from the keyboard. Each workspace remembers its folder, tabs, layout, model, and theme.	Know when an agent needs you. Waiting for input, waiting for approval, completed, and failed states are distinct. A persistent banner, native Windows notification, and taskbar flash bring you back to the exact terminal that needs attention.
Pick up yesterday's conversation. Search local Claude Code, Codex, and OpenCode sessions across projects, accounts, branches, and models. Termexo restores them through the CLIs' own claude --resume, codex resume, and opencode --session commands, reclaims a Claude session the CLI still holds open, and keeps native session files read-only.	Same CLI. Different model. Point Claude Code at Anthropic, DeepSeek, MiniMax, GLM, or a custom Anthropic-compatible endpoint. Save providers as profiles, keep API keys in Windows Credential Manager, and switch every Claude terminal in a workspace together.
Turn a task into a running agent. The task board keeps projects and tasks with priorities and acceptance criteria. Hand one to Claude Code, Codex, or OpenCode and it becomes a real terminal, moving through todo, executing, completed, and verified as that terminal reports its own status.	Let it run without babysitting. Start any agent with automatic confirmation — --permission-mode auto for Claude, --approve-for-me for Codex, --auto for OpenCode — so the AUTO chip on a terminal means the same thing whichever agent drew it.

Termexo is local by default: it has no account, cloud service, or required sync. Workspace state stays in local SQLite storage, credentials stay in Windows Credential Manager, and Claude/Codex session histories are read-only. The agent CLIs still connect to the providers you configure under their own terms and privacy policies.

The interface is available in Simplified Chinese, English, Spanish, French, German, Japanese, and Korean. It follows the Windows language automatically, or you can choose a language from the main toolbar and keep that choice across restarts.

• The window draws its own chrome. No system title bar: the top bar spans the whole window with the window controls at its right edge, and both side panels start beneath it. Dragging the bar still moves the window, double-clicking still maximises.
• Terminals render on the GPU. A long scrollback scrolls without the stutter the DOM renderer produced. Machines without a usable GPU fall back to the previous renderer.
• A terminal keeps its account. Reconnecting — including after the app restarts — rebuilds the account directory, proxy settings, and provider key from what the terminal records, instead of quietly falling back to the CLI's default home.
• Switch a terminal's account from its header. The header names the account it runs on, and picking another restarts that terminal on it with a new session, leaving the model, MCP profile, and automatic confirmation alone.
• Copy configuration between accounts. Settings, instructions, plugins, and skills move across; credentials, account identity, and session history never do.
• Sign-in is noticed on its own. A finished login refreshes the account without waiting for a CLI that keeps running after the browser flow returns.

_{A task carries its acceptance criteria from todo through to verified, and runs as a real agent terminal.}

Release notes for every earlier version live in CHANGELOG.md.

AI coding tools usually run in isolated terminals and sessions. As the number of projects grows, developers have to remember:

• which terminal belongs to which project, branch, and agent;
• which sessions are running, waiting for input, or waiting for approval;
• how to resume a specific Claude session;
• how model, endpoint, API key, and MCP configurations fit together;
• which parts of a workspace can actually be restored after an application restart.

Termexo uses the Workspace as its organizing unit and turns this scattered state into a local control plane that is observable, recoverable, and extensible.

_{Models, endpoints, and credential entry are managed in one place. Stored secrets are never returned to the frontend.}

1. Local first — Project paths, terminals, session indexes, and configuration stay on the local machine by default. Termexo does not require a Termexo cloud service.
2. Preserve native agent semantics — Prefer native session and configuration mechanisms instead of pretending that a terminated process is still alive.
3. Coordinate terminals, do not replace them — Termexo provides the workbench, state, and orchestration layer. Commands still run inside real PTYs and agents.
4. Make agent state observable — Map agent-specific events into common running, thinking, input, approval, completed, and failed states.
5. Keep security boundaries explicit — Secrets belong in the operating-system credential store, not in SQLite, snapshots, hook payloads, or logs.
6. Grow into a multi-agent architecture — Evolve around adapters, PTY, hooks, snapshots, and routing boundaries so more CLIs can be added without rebuilding the core.
7. Extend workspaces across trusted devices — Add sharing, remote access, mobile approvals, and collaboration without weakening local ownership or security boundaries.

• Claude Code and Codex both support native detection, account/model-aware launch, local session discovery, resume, and lifecycle-driven terminal states. Their event vocabularies are not identical, and compatible-provider model switching currently applies to Claude terminals.
• When the app exits, terminated operating-system processes are not “fake restored.” Termexo restores terminal configuration; historical Claude sessions must be resumed explicitly from the session center.
• Claude and Codex JSONL files are read-only. Termexo never edits, renames, or deletes them.
• Snapshot, Git, and task orchestration surfaces remain hidden until their production backends are implemented.
• V0.5 migrates a redacted context package, not a provider's private native transcript. Automatic permission approval, native transcript rewriting, and cross-agent batch model-switch transactions remain outside the current release.

See Termexo.md for the complete product plan and V0.2 architecture for current technical boundaries.

The npm package includes the Windows x64 desktop executable:

npx termexo

Or install the command globally:

npm install --global termexo
termexo

This path requires Windows 10/11, WebView2, and Node.js 18.18 or later. Building from source uses the newer toolchain listed below.

• Windows 10/11;
• Node.js ^22.22.3, ^24.15.0, or >=26.0.0;
• Rust stable, Visual Studio C++ Build Tools, and WebView2 for the desktop runtime;
• a local Claude Code and/or Codex CLI installation (Termexo can also manage installation and upgrades).

git clone https://github.com/gemron/Termexo.git
cd Termexo
npm --prefix apps/desktop-ui install

npm run dev

Open http://127.0.0.1:4200. Browser mode uses a simulated terminal with help, status, git status, and clear, making it suitable for UI development and review.

npm run tauri:dev

Desktop mode uses real PTYs. If Claude Code is not available on PATH, specify it:

$env:TERMEXO_CLAUDE_PATH = "C:\path\to\claude.exe"
npm run tauri:dev

flowchart LR
    UI["Angular Desktop UI"]
    IPC["Tauri Commands"]
    PTY["PTY Service"]
    Adapters["Agent Adapters"]
    Hooks["Hooks / Event Pipeline"]
    DB[("SQLite")]
    Vault["Windows Credential Manager"]
    Agents["Claude Code / Codex"]

    UI <--> IPC
    IPC --> PTY
    PTY --> Agents
    IPC --> Adapters
    Adapters --> Agents
    Agents --> Hooks
    Hooks --> DB
    IPC <--> DB
    IPC --> Vault

• Angular UI — workspaces, terminal layouts, session center, settings, and Inspector.
• Tauri Commands — a minimal IPC boundary between the frontend and desktop core.
• PTY Service — creates, writes to, resizes, and closes real terminal processes.
• Agent Adapters — Claude/Codex installation detection, read-only session scanning, and native launch/resume.
• Hooks Pipeline — receives agent lifecycle events, deduplicates them, and maps common terminal states.
• SQLite / Credential Manager — stores structured local data and sensitive credentials separately.

For compatibility with early installations, the database filename and some internal Tauri identifiers still use a legacy name. This does not affect the Termexo product name or new TERMEXO_* environment variables.

Next up: notification channels (#5), then the V0.7 work on workspace sharing and reaching your machine from elsewhere. See Termexo.md for dependencies and acceptance criteria, and CHANGELOG.md for what each released version actually shipped.

Termexo/
├── apps/desktop-ui/       # Angular desktop UI and browser preview
├── src-tauri/             # Rust core, PTY, agents, hooks, database, and commands
├── docs/architecture/     # Architecture notes for implemented versions
├── docs/images/           # README screenshots
└── Termexo.md             # Product design and long-term roadmap

npm run build
npm test
cargo test --manifest-path src-tauri/Cargo.toml
npm --prefix apps/desktop-ui run e2e:smoke
npm run tauri:build

With the local development server running, regenerate the README screenshots with:

npm run capture:readme

Use Issues to report bugs, discuss design decisions, or propose features. Before submitting code, make sure the change fits the current release scope and add tests for behavior changes.

Released under the MIT License.