home / skills / openclaw / skills / tmux

tmux skill

/skills/steipete/tmux

This skill automates remote tmux sessions to control interactive CLIs and capture pane output for debugging and orchestration.

npx playbooks add skill openclaw/skills --skill tmux

Review the files below or copy the command above to add this skill to your agents.

Files (4)
SKILL.md
4.0 KB
---
name: tmux
description: Remote-control tmux sessions for interactive CLIs by sending keystrokes and scraping pane output.
metadata: {"clawdbot":{"emoji":"🧵","os":["darwin","linux"],"requires":{"bins":["tmux"]}}}
---

# tmux Skill (Clawdbot)

Use tmux only when you need an interactive TTY. Prefer bash background mode for long-running, non-interactive tasks.

## Quickstart (isolated socket, bash tool)

```bash
SOCKET_DIR="${CLAWDBOT_TMUX_SOCKET_DIR:-${TMPDIR:-/tmp}/clawdbot-tmux-sockets}"
mkdir -p "$SOCKET_DIR"
SOCKET="$SOCKET_DIR/clawdbot.sock"
SESSION=clawdbot-python

tmux -S "$SOCKET" new -d -s "$SESSION" -n shell
tmux -S "$SOCKET" send-keys -t "$SESSION":0.0 -- 'PYTHON_BASIC_REPL=1 python3 -q' Enter
tmux -S "$SOCKET" capture-pane -p -J -t "$SESSION":0.0 -S -200
```

After starting a session, always print monitor commands:

```
To monitor:
  tmux -S "$SOCKET" attach -t "$SESSION"
  tmux -S "$SOCKET" capture-pane -p -J -t "$SESSION":0.0 -S -200
```

## Socket convention

- Use `CLAWDBOT_TMUX_SOCKET_DIR` (default `${TMPDIR:-/tmp}/clawdbot-tmux-sockets`).
- Default socket path: `"$CLAWDBOT_TMUX_SOCKET_DIR/clawdbot.sock"`.

## Targeting panes and naming

- Target format: `session:window.pane` (defaults to `:0.0`).
- Keep names short; avoid spaces.
- Inspect: `tmux -S "$SOCKET" list-sessions`, `tmux -S "$SOCKET" list-panes -a`.

## Finding sessions

- List sessions on your socket: `{baseDir}/scripts/find-sessions.sh -S "$SOCKET"`.
- Scan all sockets: `{baseDir}/scripts/find-sessions.sh --all` (uses `CLAWDBOT_TMUX_SOCKET_DIR`).

## Sending input safely

- Prefer literal sends: `tmux -S "$SOCKET" send-keys -t target -l -- "$cmd"`.
- Control keys: `tmux -S "$SOCKET" send-keys -t target C-c`.

## Watching output

- Capture recent history: `tmux -S "$SOCKET" capture-pane -p -J -t target -S -200`.
- Wait for prompts: `{baseDir}/scripts/wait-for-text.sh -t session:0.0 -p 'pattern'`.
- Attaching is OK; detach with `Ctrl+b d`.

## Spawning processes

- For python REPLs, set `PYTHON_BASIC_REPL=1` (non-basic REPL breaks send-keys flows).

## Windows / WSL

- tmux is supported on macOS/Linux. On Windows, use WSL and install tmux inside WSL.
- This skill is gated to `darwin`/`linux` and requires `tmux` on PATH.

## Orchestrating Coding Agents (Codex, Claude Code)

tmux excels at running multiple coding agents in parallel:

```bash
SOCKET="${TMPDIR:-/tmp}/codex-army.sock"

# Create multiple sessions
for i in 1 2 3 4 5; do
  tmux -S "$SOCKET" new-session -d -s "agent-$i"
done

# Launch agents in different workdirs
tmux -S "$SOCKET" send-keys -t agent-1 "cd /tmp/project1 && codex --yolo 'Fix bug X'" Enter
tmux -S "$SOCKET" send-keys -t agent-2 "cd /tmp/project2 && codex --yolo 'Fix bug Y'" Enter

# Poll for completion (check if prompt returned)
for sess in agent-1 agent-2; do
  if tmux -S "$SOCKET" capture-pane -p -t "$sess" -S -3 | grep -q "❯"; then
    echo "$sess: DONE"
  else
    echo "$sess: Running..."
  fi
done

# Get full output from completed session
tmux -S "$SOCKET" capture-pane -p -t agent-1 -S -500
```

**Tips:**
- Use separate git worktrees for parallel fixes (no branch conflicts)
- `pnpm install` first before running codex in fresh clones
- Check for shell prompt (`❯` or `$`) to detect completion
- Codex needs `--yolo` or `--full-auto` for non-interactive fixes

## Cleanup

- Kill a session: `tmux -S "$SOCKET" kill-session -t "$SESSION"`.
- Kill all sessions on a socket: `tmux -S "$SOCKET" list-sessions -F '#{session_name}' | xargs -r -n1 tmux -S "$SOCKET" kill-session -t`.
- Remove everything on the private socket: `tmux -S "$SOCKET" kill-server`.

## Helper: wait-for-text.sh

`{baseDir}/scripts/wait-for-text.sh` polls a pane for a regex (or fixed string) with a timeout.

```bash
{baseDir}/scripts/wait-for-text.sh -t session:0.0 -p 'pattern' [-F] [-T 20] [-i 0.5] [-l 2000]
```

- `-t`/`--target` pane target (required)
- `-p`/`--pattern` regex to match (required); add `-F` for fixed string
- `-T` timeout seconds (integer, default 15)
- `-i` poll interval seconds (default 0.5)
- `-l` history lines to search (integer, default 1000)

Overview

This skill provides remote-control of tmux sessions to drive interactive command-line programs by sending keystrokes and scraping pane output. It is designed for tasks that require an actual TTY, such as REPLs and interactive CLIs, while encouraging non-interactive work to run in background bash. The skill exposes conventions for isolated sockets, pane targeting, safe input sending, output capture, and session orchestration.

How this skill works

The skill controls tmux via a private socket and session names so multiple isolated agents can run in parallel. It sends literal keystrokes or control sequences to a target pane and captures pane history to detect prompts or collect output. Helper scripts handle finding sessions across sockets and waiting for specific text patterns with configurable timeout and polling.

When to use it

  • Running interactive REPLs or CLIs that require a real TTY.
  • Orchestrating multiple parallel coding agents or shell sessions safely.
  • Capturing live terminal output to detect prompts or job completion.
  • Spawning short-lived interactive processes that need keyboard input.

Best practices

  • Use an isolated socket directory (CLAWDBOT_TMUX_SOCKET_DIR) so sessions don’t collide.
  • Prefer literal send-keys (-l) for arbitrary input and use control sequences for signals (e.g., C-c).
  • Keep session and window names short and without spaces for reliable targeting.
  • Set PYTHON_BASIC_REPL=1 when driving Python REPLs to ensure send-keys compatibility.
  • Use capture-pane with a limited history (-S -N) and wait-for-text polling to detect completion.

Example use cases

  • Launch a Python REPL in a private tmux session and drive it by sending commands and reading responses.
  • Run multiple coding agents in parallel, each in its own session, and poll panes for shell prompts to mark completion.
  • Automate an interactive installer or test harness that cannot run fully headless.
  • Collect full pane output after a job finishes using capture-pane to archive logs.

FAQ

Does this work on Windows?

Use WSL and install tmux inside the Linux environment. The skill is gated to macOS and Linux.

How do I detect when a task finished?

Poll the pane with capture-pane and search for a prompt string (e.g., ❯ or $) or use the provided wait-for-text helper to match a regex with timeout.