totec448-spec/chat-on-steroids

Cross-platform local MCP capabilities for ChatGPT with Chrome integration, Goal, Compact & Resume, and durable multi-agent workflows.

Chat On Steroids – a desktop workbench for ChatGPT

What it is – An Electron‑based desktop application (with a companion Chrome/Edge extension) that lets you use ChatGPT as an interactive programming assistant on your own computer. It does not host a language model; it talks to the ChatGPT web UI (or an OpenRouter‑compatible API) and exposes a set of MCP (model‑client‑protocol) tools that the model can call to read/write files, run shell commands, take screenshots, control the mouse/keyboard, and spawn additional “worker” chats.

Why it matters – The official ChatGPT developer mode only offers a single, very limited API. Chat On Steroids bundles the same tool contracts that OpenAI’s Codex CLI uses, so the model already knows how to invoke them. By keeping a local transcript of every tool call and its real result, the app lets a conversation continue beyond the model’s context window and even hand‑off work to a fresh chat.

Core capabilities

Area	Tools (exposed to ChatGPT)	What they do
File & search	`read`, `view_image`, `find`, `download_artifact`	Bounded reads inside folders you approve, image preview, fast text search (ripgrep), and downloading generated artefacts.
Code editing	`apply_patch`, `write_stdin`	Pre‑flighted multi‑file patches and writing to a program’s stdin – the model can edit a repo safely before anything is written.
Shell	`exec_command`	Run a real process with interactive stdin, output limits, and background result collection.
Session	`session`, `session_finish`	Query the local durable history (30‑day default) and signal the end of a task so the app can generate a hand‑off brief.
Agents	`agents`	Spawn up to eight worker ChatGPT tabs, assign them tasks, collect their reports, and later wake them again.
Desktop (Windows/macOS only)	`observe`, `computer`	Take screenshots, inspect windows, move the mouse, type, read/write the clipboard.

All tools are gated by per‑capability switches in the Settings UI. Turning Read‑only mode on disables every write‑action, command, and desktop control in a single kill‑switch.

How it works

Install – Download the platform‑specific installer (Windows EXE, macOS DMG/ZIP, Linux AppImage or DEB). The package bundles native dependencies, a verified tunnel‑client, and the Chrome extension.
Create a Secure MCP tunnel – In the OpenAI Platform, make a tunnel and a restricted API key (read + use). The app stores these secrets in the OS keyring (DPAPI, Keychain, libsecret/KWallet).
Enable the custom app in ChatGPT – In the web UI’s Developer mode add a Core (and optionally Desktop) custom app that points at the tunnel URL.
Load the companion extension – Unpack the provided extension folder, enable Developer mode in chrome://extensions, and click Load unpacked. The extension automatically pairs with the desktop app.
Approve a project folder – In Settings → Workspace you select the directory the model may read/write. The app canonicalises every path before allowing a tool call.
Start chatting – Open a ChatGPT conversation, type a request, and the model can now call any of the enabled tools. Results are stored locally and shown in the app’s transcript view.

Session persistence & “Compact & Resume”

Every tool call and its real output are logged locally (%APPDATA%/chat‑on‑steroids/sessions/ on Windows, ~/Library/Application Support/... on macOS, ~/.config/... on Linux).
When the estimated token count of a chat exceeds a configurable threshold (≈ 400 k tokens), the app asks the model for a brief hand‑off, opens a fresh ChatGPT tab, and re‑binds the same local session to it. This lets long‑running projects survive the model’s context limits.
Pro‑tier models are exempt from automatic compaction.

Multi‑agent mode

The prime chat can launch up to eight worker chats (two are enabled by default). Workers are ordinary ChatGPT tabs that the app brokers via the agents tool.
Workers can be put to sleep, woken later, and their full history stays available to the prime chat.
When a worker’s recorded token count hits the compaction limit it becomes non‑revivable; the app will close its tab after a minute of inactivity to free memory.

Security snapshot

Aspect	Detail
File sandbox	Tools operate only inside folders you explicitly approve. Paths are canonicalised before use; there is no OS‑level sandbox, so normal user‑level race conditions still apply.
Command execution	Runs as your logged‑in user, starting in an approved folder. No additional sandbox is applied.
Desktop control	When enabled, it can affect the whole desktop (mouse, keyboard, clipboard). macOS requires the usual Screen Recording and Accessibility permissions.
MCP server	Listens on `127.0.0.1` behind a random secret path. The tunnel URL you give ChatGPT is effectively a password – treat it as secret.
Extension bridge	Separate loopback bridge used only by the extension; it does not expose file or command routes.
Secret storage	Uses Electron’s `safeStorage` – DPAPI (Windows), Keychain (macOS), libsecret/KWallet (Linux).
Read‑only mode	One‑click switch that disables all write‑actions, command execution, and desktop control.
Vulnerability reporting	Private disclosure via the repository’s `SECURITY.md`.

Getting started (quick‑start checklist)

Install the appropriate package for your OS/CPU.
Open the app (it lives in the system tray/menu bar).
In Settings → Workspace add the project folder you want the model to touch.
Create an OpenAI Secure MCP tunnel + restricted API key and paste them in Settings → Setup → Connect.
In the ChatGPT web UI enable Developer mode and add the Core (and optionally Desktop) custom app that points at the tunnel.
Load the unpacked extension from the app’s Open extension folder button.
Return to ChatGPT, start a conversation, and the model can now call tools like apply_patch or exec_command.

Who might use it?

Developers who want ChatGPT to edit code, run builds, or apply patches on their local repo without copy‑pasting.
Researchers / power users needing a persistent session that can survive the model’s context window.
Teams that want to orchestrate multiple ChatGPT “workers” for parallel subtasks while keeping everything logged locally.

Limitations & caveats

The app does not ship a language model; it only works with the official ChatGPT web UI (or an OpenRouter‑compatible endpoint).
Desktop‑control tools are only available on Windows and macOS; Linux currently lacks a backend for those actions.
Installers are not code‑signed yet, and macOS builds are not notarized – you’ll need to bypass SmartScreen/Gatekeeper warnings or build from source.
All security guarantees are at the application level; a compromised user account could still run arbitrary commands.

Resources

Download page – linked in the README (latest release).
Documentation – docs/ folder (tool contracts, plugin system, browser behavior).
Changelog – CHANGELOG.md.
Security policy – SECURITY.md.

Bottom line: Chat On Steroids turns the ChatGPT web UI into a locally‑backed development environment, giving the model safe, audited access to your filesystem, shell, and desktop so it can act as a true “pair programmer” rather than a pure text generator.