skills.rest
HTRamsey
HTRamseyCOMMUNITY
Explore all skills by this author →
GitHub

using-tmux

Automate interactive CLI tools via tmux send-keys in detached sessions.

Updated Aug 27, 2026
Search Tags:#automation#CLI#interactive#tmux#terminal
One-click install
npx skills add https://github.com/HTRamsey/claude-config --skill using-tmux
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: using-tmux
Source: https://github.com/HTRamsey/claude-config/tree/main/skills/using-tmux
Command: npx skills add https://github.com/HTRamsey/claude-config --skill using-tmux

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires tmux.

What problem does it solve?

Enables programmatic control of interactive terminal applications (editors, REPLs, prompts) that require user input.

Core Features & Use Cases

  • Quick tmux commands for session management and sending keys
  • Patterns for interactive flows (Git rebase, REPL, editing)
  • Special keys mapping and common pitfalls

Quick Start

Create a detached session and send keys, then capture output and clean up, following the examples in the quick reference.

Frequently Asked Questions about using-tmux

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I automate interactive CLI tools like Vim or git rebase that normally require terminal input?▼

Automate interactive CLI tools by using tmux to create a detached session, send programmed keystrokes via send-keys, capture output, and manage the session lifecycle. This enables scripted control of editors, REPLs, and prompts that stall waiting for user input.

Can I script input to Python or Node REPLs and other interactive terminal applications?▼

Yes, tmux enables scripted input to REPLs and interactive applications. Create a detached tmux session, send input keys programmatically, wait for responses, capture output, and terminate the session without manual interaction.

What's the core pattern for controlling interactive terminals with tmux?▼

The core pattern is: create a detached session, wait for initialization, send input keys to the session, capture and process output, and terminate the session. This approach works for git rebase -i, editors, REPLs, and any CLI that requires real terminal input.

Do I need special setup or dependencies to automate interactive CLI control?▼

Yes, you need tmux installed and enabled in your environment. The Skill requires a tmux-capable terminal to create sessions, send keystrokes, and capture output from interactive applications.

What are common pitfalls when automating interactive terminal workflows with tmux?▼

Common pitfalls include improper special keys mapping, timing issues when waiting for CLI initialization, and session cleanup failures. The Skill covers special key patterns and session lifecycle management to avoid these issues.

Can I automate git interactive workflows like `git add -p` or `git rebase -i`?▼

Yes, tmux send-keys automates git interactive workflows by programmatically sending keystroke sequences to git rebase -i, git add -p, and other interactive git commands that normally wait for terminal input.

Related Skills

Explore More Software Engineering Skills→
ratbaseratbase

tmux

Control tmux sessions, send input, and capture output programmatically.

Official
Intermediate
ZardLi1115ZardLi1115
4

himalaya

Manage terminal-based email over IMAP and SMTP with JSON output.

Community
Intermediate
ovachieverovachiever
52

using-tmux-for-interactive-commands

Control interactive CLI tools via detached tmux sessions and send-keys.

Community
Advanced
lazyFrogLOLlazyFrogLOL
127

headless-terminal

Guide headless terminal implementation using pexpect, pty, and subprocess.

Community
Intermediate