REA
Reverse engineer anything from your terminal or agent with one CLI and MCP server.
The terminal that outlives its window. Shells survive quitting the app, agents can drive other agents, and remote machines work the same way. Pure Rust, GPU-rendered.
Wenn du das gebaut hast, füge diesen Code in dein README ein. Das Badge verlinkt auf diese Seite.
[](https://mcp.popnx.com/en/skills/l0ng-ai-tty7)MCP-Server, die die KI für dieselbe Arbeit mit Diensten verbinden
Reverse engineer anything from your terminal or agent with one CLI and MCP server.
Codebase intelligence for TypeScript and JavaScript, exposed as structured MCP analysis tools.
MCP server for terminal commands, file operations, and process management
Gleiche Art Arbeit, sortiert wie die Skill-Liste
| Dieser tty7 | rea | andrej-karpathy-skills | graphify | MoneyPrinterTurbo | |
|---|---|---|---|---|---|
| Anbieter | l0ng-ai | morluto | multica-ai | Graphify-Labs | harry0703 |
| Skills | 1 | 1 | 1 | 1 | 1 |
| GitHub-Sterne | 1.505 | 465.460 | 233.910 | 149.364 | 144.149 |
| Letzte Codeänderung | 16. Nov. 2026 | 17. Nov. 2026 | 20. Apr. 2026 | 17. Nov. 2026 | 17. Nov. 2026 |
| Lizenz | Apache-2.0 | MIT | – | Apache-2.0 | MIT |
1 Skills (Anweisungssammlungen) von l0ng-ai, die eine KI liest und befolgt · kein MCP-Server
MCP = die Hände
Verbindet die KI mit einem externen Dienst oder Daten, etwa Notion lesen oder eine Rechnung erstellen. Ein Programm oder Server muss laufen.
Skill = das Handbuch
Eine Textdatei, die der KI zeigt, wie eine Aufgabe geht. Sie verbindet sich mit nichts.
Manches überschneidet sich: Einige Skills starten Skripte mit Werkzeugen, einige MCP-Server liefern nur Wissen. Geh von der Aufgabe aus.
Claude CodeCodexCursorGitHub CopilotOpenCode
Laut README des Anbieters und den Ordnern im Repo
GitHub account l0ng-ai (person), 9 years old
★ 1.505 stars · code last changed 16. Nov. 2026
No, plain text files the AI reads and follows
No scripts, so it does not go online by itself
No hooks or writes to machine settings found
Checked automatically from the repo files at commit 540261b (read only, nothing was run). Not a safety guarantee: read it and decide for yourself
Zuerst: Welche KI nutzt du?
Wähle deine App, dann zeigt diese Seite nur die Installation für diese App
Uploading to claude.ai would fail: the description is over 200 characters (1211). Use "Let the AI install it" instead
Kopiere diesen Satz und füge ihn in einen Claude Code-Chat ein
For one project, paste it into a chat that is open in that project’s folder · The AI always shows you the path before installing
The AI tells you what it will do first and asks your permission at every step
Claude Code neu starten, dann /tty7 tippen oder eine passende Aufgabe stellen; Claude nutzt den Skill
Checked against official docs 12. Nov. 2026 · Source: code.claude.com
Ein Skill sind Anweisungen, denen die KI folgt. Lies die Dateien vor der Installation und installiere nur von vertrauenswürdigen Anbietern.
Schon installiert? Zuerst prüfen · Öffne das Terminal, gib diesen Befehl ein und drücke Enter
node -vMac: ⌘ + Leertaste drücken, Terminal eingeben, Enter
Windows: Start öffnen, Windows PowerShell eingeben, dann Öffnen
Noch nicht installiert: Öffne die offizielle Download-Seite, wähle die LTS-Version und den Klick-Installer: .pkg auf dem Mac · .msi unter Windows. Doppelklicken und bis zum Ende durchklicken. Kein curl-Befehl nötig
Download-Seite von Node.js öffnen ↗
Danach das Terminal schließen, neu öffnen und denselben Befehl erneut ausführen. Es muss eine Versionsnummer erscheinen: node -v
Einmal installieren, gilt für alles, was Node.js braucht
npx skills add l0ng-ai/tty7Aus dem README des Anbieters; lädt den Code des Anbieters herunter und führt ihn aus
Mac: Command+Leertaste und Terminal tippen · Windows: Der Befehl unten funktioniert nicht in PowerShell; nutze oben „KI installiert es“
Lädt das Repo in einen temporären Ordner und kopiert nur Ordner mit einer SKILL.md
git clone --depth 1 https://github.com/l0ng-ai/tty7.git /tmp/popnx-skill-l0ng-ai-tty7-540261b && mkdir -p ~/.claude/skills && cp -R '/tmp/popnx-skill-l0ng-ai-tty7-540261b/skills/tty7' ~/.claude/skills/tty7Selbst installierte Skills funktionieren in der ChatGPT-Desktop-App, in Codex CLI und in der Codex-Erweiterung für die IDE · ChatGPT im Web und auf dem Handy kann selbst installierte Skills nicht nutzen, nur Skills, die mit einem Plugin aus dem Verzeichnis kommen
Die ChatGPT-Desktop-App enthält Codex, und Codex liest Skills aus dem Ordner ~/.agents/skills
Öffne Codex in der ChatGPT-Desktop-App und füge diesen Satz in den Chat ein
The AI always shows you the path before installing
The AI tells you what it will do first and asks your permission at every step
Lege den Ordner tty7 unter ~/.agents/skills/tty7 ab
~ ist dein Home-Ordner ($HOME)
Ein Skill sind Anweisungen, denen die KI folgt. Lies die Dateien vor der Installation und installiere nur von vertrauenswürdigen Anbietern.
Mac: Command+Leertaste und Terminal tippen · Windows: Der Befehl unten funktioniert nicht in PowerShell; nutze oben „KI installiert es“
Lädt das Repo in einen temporären Ordner und kopiert nur Ordner mit einer SKILL.md
git clone --depth 1 https://github.com/l0ng-ai/tty7.git /tmp/popnx-skill-l0ng-ai-tty7-540261b && mkdir -p ~/.agents/skills && cp -R '/tmp/popnx-skill-l0ng-ai-tty7-540261b/skills/tty7' ~/.agents/skills/tty7Checked against official docs 15. Nov. 2026 · Source: learn.chatgpt.com
Selbst installierte Skills funktionieren hier nicht, nur Skills, die mit einem Plugin aus dem Verzeichnis kommen
Um diesen Skill mit ChatGPT zu nutzen, verwende die ChatGPT-Desktop-App wie oben beschrieben
Checked against official docs 15. Nov. 2026 · Source: learn.chatgpt.com
Kopiere diesen Satz und füge ihn in einen Codex-Chat ein · Funktioniert in Codex in der ChatGPT-Desktop-App, in Codex CLI und in der IDE-Erweiterung
For one project, paste it into a chat that is open in that project’s folder · The AI always shows you the path before installing
The AI tells you what it will do first and asks your permission at every step
Codex erkennt neu installierte Skills selbst; wenn einer nicht erscheint, starte Codex neu · So nutzt du ihn: In ChatGPT @ tippen und den Skill wählen · in Codex CLI oder der IDE-Erweiterung /skills ausführen oder $ und den Skill-Namen tippen
Checked against official docs 15. Nov. 2026 · Source: learn.chatgpt.com
Ein Skill sind Anweisungen, denen die KI folgt. Lies die Dateien vor der Installation und installiere nur von vertrauenswürdigen Anbietern.
Mac: Command+Leertaste und Terminal tippen · Windows: Der Befehl unten funktioniert nicht in PowerShell; nutze oben „KI installiert es“
Lädt das Repo in einen temporären Ordner und kopiert nur Ordner mit einer SKILL.md
git clone --depth 1 https://github.com/l0ng-ai/tty7.git /tmp/popnx-skill-l0ng-ai-tty7-540261b && mkdir -p ~/.agents/skills && cp -R '/tmp/popnx-skill-l0ng-ai-tty7-540261b/skills/tty7' ~/.agents/skills/tty7Kopiere diesen Satz und füge ihn in einen Cursor-Chat ein
For one project, paste it into a chat that is open in that project’s folder · The AI always shows you the path before installing
The AI tells you what it will do first and asks your permission at every step
Im Agent-Chat von Cursor / tippen und tty7 wählen
Checked against official docs 12. Nov. 2026 · Source: cursor.com
Ein Skill sind Anweisungen, denen die KI folgt. Lies die Dateien vor der Installation und installiere nur von vertrauenswürdigen Anbietern.
Mac: Command+Leertaste und Terminal tippen · Windows: Der Befehl unten funktioniert nicht in PowerShell; nutze oben „KI installiert es“
Lädt das Repo in einen temporären Ordner und kopiert nur Ordner mit einer SKILL.md
git clone --depth 1 https://github.com/l0ng-ai/tty7.git /tmp/popnx-skill-l0ng-ai-tty7-540261b && mkdir -p ~/.cursor/skills && cp -R '/tmp/popnx-skill-l0ng-ai-tty7-540261b/skills/tty7' ~/.cursor/skills/tty7Für andere Apps, die Skills lesen. Der Satz enthält die Pfade für Claude Code, Codex und Cursor, damit die KI den für deine App wählt · Copy this sentence into the app’s chat
For one project, paste it into a chat that is open in that project’s folder · The AI always shows you the path before installing
The AI tells you what it will do first and asks your permission at every step
Checked against official docs 12. Nov. 2026 · Source: code.claude.com, learn.chatgpt.com, cursor.com
Andere Apps mit Agent Skills (etwa Gemini CLI oder GitHub Copilot) nutzen andere Ordner. Sieh in deren Anleitung nach und kopiere den Ordner mit der SKILL.md dorthin.
Skill-Ordner am 11. Nov. 2026 mit den offiziellen Anleitungen von Claude Code, Codex und Cursor geprüft
✓ Befehle geprüft am 18. Nov. 2026
Der folgende Text stammt aus dem Repo des Anbieters, nicht von PopNx MCP
Die ersten 8.000 Zeichen · Ganze Datei auf GitHub öffnen
---
name: tty7
description: >-
Drive the tty7 terminal workbench from the shell with the `tty7` binary — list workspaces/tabs/panes, split a pane, send text or keystrokes into one, capture what is on a pane's screen, run a command in a real PTY and pass its exit code through, run a command in a shell pane you already have and get back its output and exit code, block until a pane finishes or needs input, see which coding agents are running and which ports a pane is listening on. Use this whenever tty7, panes, workspaces, or `%42`/`@7`/"the other pane"/"the other agent" come up; whenever you want to hand work to another agent and collect the result ("get Claude/Codex to do X", "派个活", "let another agent handle this", running several agents in parallel and merging what they produce); whenever you need to start something long-running or interactive (dev server, REPL, ssh session, `tail -f`, a TUI) that should not sit blocking your Bash tool; whenever a program needs a real terminal to behave the way the user sees it; and whenever you need to look at or report on what is running in some *other* terminal on this machine. Cheap to check: if `$TTY7_PANE` is set you are already inside tty7 and every command here works with no setup.
---
# Driving tty7 from the command line
`tty7` is a thin, non-interactive client of the tty7 server. Every verb returns
and exits; `--json` makes the output machine-readable. The GUI never has to be
running — the server is what owns the panes.
## First: where are you?
```bash
tty7 doctor
```
One table, and it answers everything you need before doing anything else:
whether a server is reachable, whether the dialect matches, whether each agent's
status hooks are installed, and whether `TTY7_CONFIG_DIR` / `TTY7_WS` /
`TTY7_PANE` are set — i.e. whether you are running *inside* a tty7 pane.
Being inside a pane matters for two reasons: the address-taking verbs
(`split`, `send`, `exec`, `capture`, `procs`, `wait`, `pane close`) default to
`$TTY7_PANE`, and `run --keep` files its pane into `$TTY7_WS`. Outside a tty7
shell you must name a target explicitly, and the error will say so rather than
guessing.
The hooks row matters if you intend to delegate to another agent: without them
an agent reports no status, so `tty7 wait` on it will only ever time out.
If `tty7 doctor` says the server is unreachable, stop and tell the user — do
not run `tty7 server start` on your own initiative. Starting a server they
didn't ask for changes what their GUI attaches to.
## What are you here to do?
Four jobs, four shapes:
1. **Run something that shouldn't block you or needs a real TTY** — a dev
server, a long test run, a TUI. [Running a command](#running-a-command-two-shapes).
2. **Talk to something stateful over time** — a REPL, `ssh`, a debugger.
Same primitives: [send](#non-blocking-a-pane-you-talk-to-over-time),
[read](#reading-a-pane), repeat.
3. **Look at what this machine is doing** — other panes, other agents, ports.
[Looking around](#looking-around), strictly read-only.
4. **Hand work to another coding agent** — one worker or a fan-out of several.
Read `references/delegation.md` first; the short version is
[below](#handing-work-to-another-agent).
The Bash tool remains right for anything that starts, does its job, and exits
without needing a terminal or an audience. A pane earns its keep when the
process outlives your turn, needs a real PTY, or should be visible to the user
in their tty7 window — that last one is often the whole point.
## Addresses
| Shape | Means | Stable? |
|---|---|---|
| `%42` | a pane | yes — a pane keeps its id for its whole life |
| `@7` | a tab, numbered across the **whole machine** in tree order | **no** — it shifts whenever a workspace or tab appears or disappears |
| `@<full tab UUID>` | that same tab, by id | yes |
| `api` / `76698a44` / a full UUID | a workspace, by name, by unique id prefix, or by id | yes |
Re-resolve `@N` right before you use it; never cache one across a step that
creates or removes a tab. Pane ids, tab ids and workspace ids are safe to
remember — so when you create a tab and mean to address it again later, keep the
id `tty7 tab new --json` hands back rather than counting `@N` a second time.
The sigils are optional wherever an address is expected: `%42` and `42` are the
same pane, `@7` and `7` the same tab. Ids copied out of `--json` paste straight
back in.
Omitting the address inside a tty7 shell means "this pane" / "this workspace".
An explicit address always wins over the environment.
## Running a command: three shapes
### Blocking, with a real exit code
```bash
tty7 run -- cargo test # streams to your stdout, exits with cargo's code
tty7 run --cwd /path -- make
tty7 run --keep -- cargo build # leaves the pane as a new tab afterwards
```
The command's output streams to your stdout as it happens, and `tty7` exits
with the command's own exit code. This is the closest thing to a Bash call —
the difference is the PTY and the fact that the user can see it.
Three things to know. `--keep` needs a workspace, so it only works inside a tty7
shell or with `--ws <workspace>`. With `--json`, the streamed output comes first
and the JSON object last — the combined stream is *not* parseable as JSON, so
read the last line. And the pane is 120 columns wide with no way to change it,
so output that assumes a wider terminal wraps.
### Blocking, in a pane you already have
```bash
tty7 exec "$PANE" --timeout 900 -- cargo test # prints its output, exits with its code
```
`exec` types the line at the pane's shell prompt — its cwd, its environment,
its history — waits for the prompt to come back, prints what the command
printed (as text, like `capture --plain`; `--raw` keeps the escapes) and exits
with the command's own code. It is how you run the next command in a pane you
set up earlier (a `cd`, an activated venv, an `ssh` session with tty7's shell
integration on the far end) without the send / wait / capture / guess dance.
What it needs, and says when it doesn't have: the pane's shell must have tty7's
shell integration (a pane that has never sent a prompt mark is refused), and
the pane must be sitting at a prompt (a busy one is refused — `wait --until
free` first). The words after `--` become one shell line, so `&&`, pipes and
redirections work if you quote them: `tty7 exec %3 -- 'make && ./run'`. Always
give `--timeout` when nobody is watching: a line the shell never runs — an
unclosed quote waiting on `dquote>` — has no end to wait for. On timeout it
exits 124 and leaves the command running.
### Non-blocking: a pane you talk to over time
This is the one that makes tty7 worth reaching for. Get a pane, send it work,
come back later.
```bash
PANE=$(tty7 split --v) # or --h; splits $TTY7_PANE, prints "%83"
tty7 send "$PANE" 'npm run dev' --enter
```
`split` prints the new pane's address on stdout, which is what you capture into
a variable. Without an axis it is a usage error — `--v` stacks the new pane
below, `--h` puts it to the right.
Splitting `$TTY7_PANE` changes the user's visible layout, which is usually the
point: they can watch the dev server you started. Say that you did it, and close
the pane when you're done with it.
If you are *not* inside a tty7 pane there is nothing to split, so make your own
place to work first. `tty7 new --json /path/to/repo` hands you both ids at
once — don't go digging through `ws tree` for the pane:
```bash
read -r WS PANE < <(tty7 new --json /path/to/repo \
| python3 -c 'import json,sys; d=json.load(sys.stdin); print(d["id"], "%%%d" % d["pane"])')
```
`send` types text into the pane exactly as a keyboard would; `--enter` appends
the carriage return, or presses Enter on its own when you give it no text
(`tty7 send "$PANE" --enter` runs what is already typed there). It does not
wait and it does not tell you what happened — reading is a separate step, and
waiting is `tty7 wait`.
For keystrokes rather tFragen, Tipps teilen oder melden, dass etwas nicht geht. Sortiert nach „hilfreich“.
Noch keine Beiträge. Stell die erste Frage oder teile einen Tipp.
Beiträge hier stammen von Nutzern, nicht vom PopNx-Team.