peekme 0.2.3 → 0.3.1

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 0.3.1 (2026-09-28)
+
+- Alt+P and Option+P work inside tmux with Claude Code and Codex. Inside tmux these agents do not
+  send a mouse selection to the terminal, they give it to tmux, so peekme saw nothing and Option+P
+  typed `π`. peekme now reads the selection from tmux. This also covers SSH with tmux on the
+  other side.
+- With tmux handling the mouse (`set -g mouse on`) and Claude Code's classic screen, a selection
+  made with tmux can be explained too.
+- Every release is now tested through tmux and SSH in many combinations, and in the real Terminal
+  and iTerm2 on macOS, in their default settings and with Option as Meta.
+
+## 0.3.0 (2026-09-28)
+
+- peekme works with GitHub Copilot CLI too. Type `copilot` as always, select text, press Alt+P.
+  Run `peekme install` once more so that `copilot` gets peekme.
+- Copilot explanations come from Copilot CLI's own headless server with your Copilot login.
+  Each one is a short session without tools, and peekme deletes it afterwards, so it does not
+  show in your session list. The context comes from the running session's log.
+- peekme reads Copilot's selection from the OSC 52 copy it sends when you release the mouse,
+  also over SSH and in tmux. Copilot's input line stays live under the box.
+
 ## 0.2.3 (2026-09-28)
 
 - Option+P works on a Mac also over SSH and inside tmux. 0.2.2 found out from the environment

package/README.md

@@ -1,7 +1,8 @@
 # peekme
 
-Peek me. Pick me. Select text in [Codex CLI](https://github.com/openai/codex) or
-[Claude Code](https://github.com/anthropics/claude-code) output, press **Alt+P** (**Option+P** on a Mac), and a short
+Peek me. Pick me. Select text in [Codex CLI](https://github.com/openai/codex),
+[Claude Code](https://github.com/anthropics/claude-code) or
+[GitHub Copilot CLI](https://github.com/github/copilot-cli) output, press **Alt+P** (**Option+P** on a Mac), and a short
 explanation opens right next to that text, inside the terminal. The other lines move to make
 room, like Peek in VS Code. Esc closes it and the screen is exactly as before.
 
@@ -10,11 +11,13 @@ room, like Peek in VS Code. Esc closes it and the screen is exactly as before.
 The explanation comes from a small, fast model and it knows the conversation. If you select
 "its split panes" in an answer that recommends Kitty, it tells you it is about Kitty.
 
-Status: 0.2.3. Tested on Linux with X11 and bash, with Codex 0.157 and Claude Code 2.1.283.
+Status: 0.3.1. Tested with Codex 0.157, Claude Code 2.1.283 and Copilot CLI 1.0.89 on Linux, also
+inside tmux and over SSH. On macOS it is tested in Terminal and iTerm2 with a stand-in agent, also
+inside tmux and over SSH.
 
 ## Install
 
-You need Codex CLI or Claude Code (logged in). Both is fine too. Then install peekme in one of
+You need Codex CLI, Claude Code or GitHub Copilot CLI (logged in). More than one is fine too. Then install peekme in one of
 these ways and run `peekme install`:
 
 ```
@@ -35,10 +38,10 @@ Without npm, Homebrew or Rust, the script from the
 curl --proto '=https' --tlsv1.2 -LsSf https://github.com/GregoryBolshakov/peekme/releases/latest/download/peekme-installer.sh | sh
 ```
 
-Ready binaries are there too, for Linux and macOS on x86_64 and ARM. macOS is not tested yet.
+Ready binaries are there too, for Linux and macOS on x86_64 and ARM.
 
-After this, `codex` and `claude` open with peekme in every new terminal. You keep typing
-`codex` or `claude`, and your aliases and scripts that call them keep working. `peekme install`
+After this, `codex`, `claude` and `copilot` open with peekme in every new terminal. You keep
+typing them as always, and your aliases and scripts that call them keep working. `peekme install`
 adds a short, marked block to your `~/.bashrc` or `~/.zshrc` (for fish, a file in
 `~/.config/fish/conf.d`). If you install one of the agents later, it gets peekme too.
 
@@ -47,17 +50,19 @@ peekme doctor      # check the setup, and see what is in the way if something is
 peekme uninstall   # remove the block, your files are as before
 command codex      # run plain Codex once
 command claude     # run plain Claude Code once
+command copilot    # run plain Copilot CLI once
 ```
 
 The first time you run `peekme` on its own, it asks if it should do `peekme install` for you.
 
-Upgrading from 0.1: run `peekme install` once more, so that `claude` gets peekme too.
+Upgrading from an older peekme: run `peekme install` once more, so that `claude` and `copilot`
+get peekme too.
 
 ## Use
 
-Start Codex or Claude Code as always. Select text with the mouse as you normally do, then press
-Alt+P. When the agent draws full screen (Codex since 0.157, Claude Code with
-`"tui": "fullscreen"`), it makes the selection itself, and peekme uses that selection.
+Start Codex, Claude Code or Copilot CLI as always. Select text with the mouse as you normally
+do, then press Alt+P. When the agent draws full screen (Codex since 0.157, Copilot CLI, Claude
+Code with `"tui": "fullscreen"`), it makes the selection itself, and peekme uses that selection.
 
 | Key | When | What it does |
 |---|---|---|
@@ -78,7 +83,8 @@ you type Greek, `π` stays a letter. If your terminal sends Option as Meta, Opti
 When the agent draws full screen, peekme gets the selection from the agent. Otherwise (Claude
 Code's classic screen) it reads the clipboard: iTerm2 copies a selection there by itself, in
 Terminal press Cmd+C after you select. Over SSH only the agent's own selection can be read, so
-use the full screen mode there (Codex uses it by default, Claude Code with `"tui": "fullscreen"`).
+use the full screen mode there (Codex and Copilot CLI use it by default, Claude Code with
+`"tui": "fullscreen"`).
 
 In Claude Code, Alt+P opens the model picker. With peekme it explains the selection instead.
 `/model` still opens the model picker.
@@ -91,13 +97,17 @@ No API key is needed. peekme asks the agent's own CLI, with your existing login:
 - Claude Code: `claude -p` on Haiku, without tools and without saving the session, so nothing
   appears in `/resume`. After the first explanation one `claude -p` waits in the background for
   the next one, so it starts in about half a second. It takes about 210 MB.
+- Copilot CLI: its headless server (`copilot --headless`, the one the Copilot SDK uses), started
+  on the first explanation. Each explanation is a short session without tools, and peekme
+  deletes it afterwards, so nothing appears in your session list. The model is Copilot's Auto
+  unless you set one. It uses a little of your AI credits for each explanation.
 
 It does use your plan, a little for each explanation. Nothing starts before the first Alt+P.
 
 Only the interactive screen gets peekme: `codex`, `codex "prompt"`, `codex resume`,
-`codex fork`, and `claude`, `claude "prompt"`, `claude --resume`, `claude -c`. Commands like
-`codex exec`, `codex mcp`, `claude -p` or `claude mcp`, and anything with output going to a pipe
-or a file, run the agent directly.
+`codex fork`, `claude`, `claude "prompt"`, `claude --resume`, `claude -c`, and `copilot`,
+`copilot -i "prompt"`, `copilot --resume`. Commands like `codex exec`, `claude -p`, `copilot -p`
+or `copilot login`, and anything with output going to a pipe or a file, run the agent directly.
 
 ## How it works
 
@@ -108,8 +118,8 @@ what is on your screen.
 On Alt+P it takes the selection and finds it on the screen:
 
 - Codex full screen: the text Codex highlighted.
-- Claude Code full screen: Claude copies the selection with an OSC 52 escape sequence when you
-  release the mouse. peekme reads the text from that sequence as it passes through, and knows
+- Claude Code and Copilot CLI full screen: the agent copies the selection with an OSC 52 escape
+  sequence when you release the mouse. peekme reads the text from that sequence as it passes through, and knows
   where the drag ended. This also works over SSH.
 - Otherwise: your terminal's mouse selection (the X11 PRIMARY selection).
 
@@ -120,7 +130,7 @@ that arrives while the box is open is kept aside.
 
 On Esc it draws those rows again from a copy taken when the box opened. After that it sends the
 kept output, so the terminal ends in the same state as if the box never existed. Tests check
-this cell by cell on real Codex and Claude Code output.
+this cell by cell on real Codex, Claude Code and Copilot CLI output.
 
 ### What the model gets
 
@@ -136,8 +146,9 @@ slow. So the model gets small parts, each with a size limit:
 3. Your request that this text answers, and one line for each of your earlier requests.
 4. The first places in the conversation where the same words were used before.
 
-The conversation comes from Codex's app-server, or from Claude Code's session transcript in
-`~/.claude/projects` (peekme knows which one, because Claude registers its process id).
+The conversation comes from Codex's app-server, from Claude Code's session transcript in
+`~/.claude/projects`, or from Copilot CLI's session log in `~/.copilot/session-state`. peekme
+knows which session, because the agent registers its process id there.
 
 Usually this is 1 to 7 KB of text. When it is not enough, press Alt+P again and the model gets
 the whole conversation. A long chat can be 5 to 30 times bigger than a normal explanation, so
@@ -153,21 +164,23 @@ more.
 | `PEEKME_OWN_SERVER` | set to 1 to start peekme's own `codex app-server` instead of using the shared one |
 | `PEEKME_CLAUDE_MODEL` | model for Claude Code explanations. Default is `haiku` |
 | `PEEKME_CLAUDE_BIN` | claude binary to use for explanations. Default is `claude` |
+| `PEEKME_COPILOT_MODEL` | model for Copilot CLI explanations. Default is Copilot's Auto |
+| `PEEKME_COPILOT_BIN` | copilot binary to use for explanations. Default is `copilot` |
 | `PEEKME_SELECTION` | use this text instead of the mouse selection, for testing |
 
-### How `codex` and `claude` get peekme
+### How `codex`, `claude` and `copilot` get peekme
 
 `peekme install` does two things:
 
-1. It defines shell functions `codex` and `claude` in your shell setup. A function wins over
+1. It defines shell functions `codex`, `claude` and `copilot` in your shell setup. A function wins over
    anything on PATH, so it keeps working when nvm, mise, Homebrew or an agent's installer
-   change PATH later. Aliases that call `codex` or `claude` go through it too.
-2. It puts `codex` and `claude` links to peekme in `~/.local/share/peekme/bin` at the front of
+   change PATH later. Aliases that call them go through it too.
+2. It puts `codex`, `claude` and `copilot` links to peekme in `~/.local/share/peekme/bin` at the front of
    PATH, so scripts that run them also get peekme. If some tool puts its own directory in front
    of it later, only scripts lose peekme, and `peekme doctor` tells you which directory it is.
 
 Both find the real agent on PATH themselves, so updating the agent changes nothing. If you
-remove peekme, the functions fall back to plain `codex` and `claude`.
+remove peekme, the functions fall back to the plain agents.
 
 To use peekme with another program, run `peekme -- COMMAND`.
 
@@ -191,19 +204,21 @@ To use peekme with another program, run `peekme -- COMMAND`.
 cargo test
 cargo clippy --all-targets
 cargo run --example vtdump -- capture.bin 120 40 [offset]
-cargo run --example peek_text -- "<screen text>" "<selection>" [--deep] [--claude [--pid PID]]
+cargo run --example peek_text -- "<screen text>" "<selection>" [--deep] [--claude|--copilot] [--pid PID]
 python3 spikes/capture.py out.bin 120 40 "<script>" -- peekme claude
 python3 spikes/flicker_test.py
 python3 spikes/explain_probe.py
+python3 spikes/copilot_probe.py info
 ```
 
 `vtdump` replays a captured byte stream and prints the screen. `peek_text` runs one explanation
 without a terminal and prints the exact prompt. `capture.py` runs a command in a pseudo-terminal,
 sends keys and mouse events from a script and saves everything it prints. `flicker_test.py`
 shows if your terminal flickers when a program switches screens. `explain_probe.py` makes one
-explanation request to `codex app-server` and prints timings.
+explanation request to `codex app-server` and prints timings. `copilot_probe.py` does the same
+with Copilot CLI's headless server.
 
-Each agent has its own folder in `src/` (`codex/`, `claude/`): how its selection is read, where
+Each agent has its own folder in `src/` (`codex/`, `claude/`, `copilot/`): how its selection is read, where
 its conversation comes from, and which model explains. The rest is shared.
 
 ## License

package/npm-shrinkwrap.json

@@ -19,7 +19,7 @@
       "hasInstallScript": true,
       "license": "MIT OR Apache-2.0",
       "name": "peekme",
-      "version": "0.2.3"
+      "version": "0.3.1"
     },
     "node_modules/detect-libc": {
       "engines": {
@@ -48,5 +48,5 @@
     }
   },
   "requires": true,
-  "version": "0.2.3"
+  "version": "0.3.1"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "artifactDownloadUrls": [
-    "https://github.com/GregoryBolshakov/peekme/releases/download/v0.2.3"
+    "https://github.com/GregoryBolshakov/peekme/releases/download/v0.3.1"
   ],
   "author": "Gregory Bolshakov",
   "bin": {
@@ -9,7 +9,7 @@
   "dependencies": {
     "detect-libc": "^2.1.2"
   },
-  "description": "Select text in Codex CLI or Claude Code output and get a short explanation right under it, inside the terminal",
+  "description": "Select text in Codex CLI, Claude Code or GitHub Copilot CLI output and get a short explanation right under it, inside the terminal",
   "devDependencies": {
     "prettier": "^3.8.3"
   },
@@ -26,9 +26,9 @@
     "command-line-utilities",
     "codex",
     "claude",
+    "copilot",
     "terminal",
-    "cli",
-    "explain"
+    "cli"
   ],
   "license": "MIT OR Apache-2.0",
   "name": "peekme",
@@ -69,7 +69,7 @@
       "zipExt": ".tar.xz"
     }
   },
-  "version": "0.2.3",
+  "version": "0.3.1",
   "volta": {
     "node": "18.14.1",
     "npm": "9.5.0"