Przejdź do treści
Biblioteka skilli
Programowanie · Automatyzacja

cli-controller

/cli-controller

Steruje interaktywnymi aplikacjami wiersza poleceń: debugowanie przez pdb, gdb i jshell, uruchamianie instancji Claude Code oraz praca z REPL-ami i długo działającymi procesami.

Repozytorium
nexus ↗
Licencja
AGPL-3.0
Ostatnia zmiana repozytorium
26.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
1
Adresy URL w SKILL.md
1
Przestarzałość

Brak sygnałów. Repozytorium zmienione 26.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

AGPL-3.0, copyleft: przeróbki udostępniane innym muszą mieć tę samą licencję.

Co sprawdzić przed instalacją
  • SKILL.md zawiera komentarze HTML (1). Nie widać ich w podglądzie Markdown, a model je czyta.

Co robi i kiedy

Steruje interaktywnymi aplikacjami wiersza poleceń: debugowanie przez pdb, gdb i jshell, uruchamianie instancji Claude Code oraz praca z REPL-ami i długo działającymi procesami.

Oryginalny opis (EN)

Use when controlling interactive CLI applications, debugging with pdb/gdb/jshell, spawning Claude Code instances, or working with REPLs and long-running processes

Jak działa

  1. When This Skill Activates
  2. Core Primitives
  3. Core Principles
  4. Quick Reference Workflows
  5. Error Handling Pattern
  6. Troubleshooting
  7. Best Practices
Sekcje z nagłówków SKILL.md, w oryginale · 250 linii, 1 331 słów
Podgląd SKILL.md
---
name: cli-controller
description: Use when controlling interactive CLI applications, debugging with pdb/gdb/jshell, spawning Claude Code instances, or working with REPLs and long-running processes
effort: medium
---

# CLI Controller Skill

This is a **standalone skill** that provides workflows and best practices for interactive CLI control using raw tmux commands. No additional tools required — just tmux on PATH.

## When This Skill Activates

- Debug Python, Java, or other code interactively
- Spawn Claude Code instances for parallel work
- Control long-running interactive processes
- Test web applications with coordinated automation
- Work with REPLs or interactive CLIs
- Monitor and interact with build processes

For simple one-off commands, use the regular Bash tool instead.

## Core Primitives

All operations use `tmux` directly via Bash. Key commands:

| Operation | Command |
|-----------|---------|
| Launch shell in new pane | `tmux split-window -h -P -F '#{session_name}:#{window_index}.#{pane_index}' zsh` |
| Send text + Enter | `tmux send-keys -t $PANE 'command here' Enter` |
| Send text without Enter | `tmux send-keys -t $PANE 'partial text'` |
| Capture pane output | `tmux capture-pane -t $PANE -p` |
| Capture last N lines | `tmux capture-pane -t $PANE -p -S -50` |
| Kill pane | `tmux kill-pane -t $PANE` |
| List panes | `tmux list-panes -F '#{pane_index} #{pane_current_command} #{pane_id}'` |
| Send Ctrl+C | `tmux send-keys -t $PANE C-c` |
| Send Escape | `tmux send-keys -t $PANE Escape` |

### Pane Targeting

Panes are addressed as `session:window.pane`:
- `myapp:1.2` — session "myapp", window 1, pane 2
- Just use the value returned by `split-window -P -F '#{session_name}:#{window_index}.#{pane_index}'`

## Core Principles

### 1. Always Launch Shell First
**CRITICAL**: Never launch commands directly — always launch a shell first.

```bash
# CORRECT - Launch shell, then run command inside it
PANE=$(tmux split-window -h -P -F '#{session_name}:#{window_index}.#{pane_index}' zsh)
sleep 0.5
tmux send-keys -t "$PANE" 'python script.py' Enter

# WRONG - Direct command (if it errors, pane closes and you lose output!)
tmux split-window -h 'python script.py'
```

### 2. Wait for Idle Instead of Arbitrary Sleeps

Poll until pane output stabilizes (no changes for N seconds):

```bash
# Wait for pane to become idle (no output changes for 2 seconds)
wait_idle() {
    local pane="$1" idle_secs="${2:-2}" timeout="${3:-60}"
    local last_hash="" hash="" start=$(date +%s) last_change=$(date +%s)
    while true; do
        local now=$(date +%s)
        (( now - start > timeout )) && return 1
        hash=$(tmux capture-pane -t "$pane" -p | md5sum | cut -d' ' -f1)
        if [[ "$hash" != "$last_hash" ]]; then
            last_hash="$hash"; last_change=$now
        elif (( now - last_change >= idle_secs )); then
            return 0
        fi
        sleep 0.5
    done
}

# Usage:
tmux send-keys -t "$PANE" 'long_running_command' Enter
wait_idle "$PANE" 2 60
output=$(tmux capture-pane -t "$PANE" -p)
```

### 3. Execute with Exit Code Capture

For commands where you need the exit code, use marker-based execution:

```bash
# Execute and capture exit code
tmux_execute() {
    local pane="$1" cmd="$2" timeout="${3:-30}"
    local marker="__EXEC_${RANDOM}_$(date +%s)__"
    tmux send-keys -t "$pane" "echo ${marker}_START; { ${cmd}; } 2>&1; echo ${marker}_END:\$?" Enter
    local start=$(date +%s)
    while (( $(date +%s) - start < timeout )); do
        local captured=$(tmux capture-pane -t "$pane" -p -S -500)
        if [[ "$captured" == *"${marker}_END:"* ]]; then
            local exit_code=$(echo "$captured" | grep -o "${marker}_END:[0-9]*" | sed "s/${marker}_END://")
            local output=$(echo "$captured" | sed -n "/${marker}_START/,/${marker}_END/p" | sed '1d;$d')
            echo "EXIT_CODE=$exit_code"
            echo "$output"
            return "$exit_code"
        fi
        sleep 0.5
    done
    echo "EXIT_CODE=-1 (timeout)"
    return 1
}

# Usage:
tmux_execute "$PANE" "pytest tests/" 120
```

### 4. Always Capture Before Killing
```bash
output=$(tmux capture-pane -t "$PANE" -p)
tmux kill-pane -t "$PANE"
```

## Quick Reference Workflows

### Python Debugging
```bash
PANE=$(tmux split-window -h -P -F '#{session_name}:#{window_index}.#{pane_index}' zsh)
sleep 0.5
tmux send-keys -t "$PANE" 'python -m pdb script.py' Enter
sleep 1
tmux send-keys -t "$PANE" 'b function_name' Enter   # breakpoint
tmux send-keys -t "$PANE" 'c' Enter                  # continue
tmux send-keys -t "$PANE" 'p variable' Enter          # print
sleep 0.5
output=$(tmux capture-pane -t "$PANE" -p)
tmux send-keys -t "$PANE" 'q' Enter
sleep 0.3
tmux kill-pane -t "$PANE"
```

### Spawning Claude Code

**Two gotchas specific to Claude Code:**

1. **Splash screen swallows the first Enter.** Claude shows a welcome splash on first launch that absorbs the keystroke. Always type the prompt first, wait for idle (splash gone), then send a bare `Enter`.
2. **Persistent footer lines confuse idle detection.** Claude's UI always renders a status footer (`⎇ main`, context %, `bypass permissions on`). The standard hash-based `wait_idle` will never settle on "no changes" while Claude is actively generating. Instead, **poll for content markers** (specific strings you expect in the response) rather than waiting for the output to stop changing.

```bash
PANE=$(tmux split-window -h -P -F '#{session_name}:#{window_index}.#{pane_index}' zsh)
sleep 0.5
tmux send-keys -t "$PANE" 'cd /path/to/project && claude --dangerously-skip-permissions' Enter

# Wait for splash to clear (Claude idle at ❯ prompt)
sleep 5

# Type prompt text into the input field (no Enter yet)
tmux send-keys -t "$PANE" 'Analyze performance in src/processor.py'
sleep 0.3
# Now send Enter — splash is gone, this goes to Claude
tmux send-keys -t "$PANE" Enter

# Poll for content markers instead of idle detection
for i in $(seq 1 60); do
    sleep 2
    output=$(tmux capture-pane -t "$PANE" -p -S -100)
    # Replace with strings you expect to appear in the response
    if echo "$output" | grep -qE "hotspot|bottleneck|O\(n\)|performance|✓|✗"; then
        break
    fi
done

analysis=$(tmux capture-pane -t "$PANE" -p -S -200)
# Exit Claude cleanly
tmux send-keys -t "$PANE" C-c
sleep 0.3
tmux send-keys -t "$PANE" '/exit' Enter
sleep 1
tmux kill-pane -t "$PANE"
```

### REPL Sessions
```bash
PANE=$(tmux split-window -h -P -F '#{session_name}:#{window_index}.#{pane_index}' zsh)
sleep 0.5
tmux send-keys -t "$PANE" 'python3' Enter
sleep 1
tmux send-keys -t "$PANE" 'import requests' Enter
tmux send-keys -t "$PANE" "response = requests.get('https://api.example.com')" Enter
wait_idle "$PANE" 2 30
output=$(tmux capture-pane -t "$PANE" -p)
tmux send-keys -t "$PANE" 'exit()' Enter
sleep 0.3
tmux kill-pane -t "$PANE"
```

### Long-Running Process Monitoring
<!-- nx-mvnw-allowlist (nexus-c00dw): generic tmux-driving example, not
     scoped to this repo's own service/ build — `mvn clean install` here
     illustrates the pattern for ANY project this skill might drive, not a
     literal command wired to nexus's service/target lease. -->
```bash
PANE=$(tmux split-window -h -P -F '#{session_name}:#{window_index}.#{pane_index}' zsh)
sleep 0.5
tmux send-keys -t "$PANE" 'mvn clean install' Enter
for i in {1..30}; do
    sleep 10
    output=$(tmux capture-pane -t "$PANE" -p -S -50)
    [[ "$output" =~ "BUILD SUCCESS" ]] && break
    [[ "$output" =~ "BUILD FAILURE" ]] && break
done
final=$(tmux capture-pane -t "$PANE" -p)
tmux kill-pane -t "$PANE"
```

## Error Handling Pattern
```bash
PANE=$(tmux split-window -h -P -F '#{session_name}:#{window_index}.#{pane_index}' zsh)
[[ -z "$PANE" ]] && { echo "Failed to launch pane"; return 1; }
sleep 0.5
tmux send-keys -t "$PANE" 'risky_command' Enter
wait_idle "$PANE" 2 30
output=$(tmux capture-pane -t "$PANE" -p)
if [[ "$output" =~ "error" ]]; then
    echo "Failed: $output"
    tmux kill-pane -t "$PANE"
    return 1
fi
tmux kill-pane -t "$PANE"
```

## Troubleshooting

| Problem | Solution |
|---------|----------|
| Pane closed unexpectedly | Always launch shell first |
| Missing output | Use `wait_idle` or longer sleep before capture |
| Commands not executing | Add sleep/wait_idle between commands |
| Timeout waiting | Increase timeout or check if process is stuck |
| Enter key not received | Add `sleep 0.3` between send-keys calls |
| Claude ignores first prompt | Splash screen absorbs the first Enter — type prompt, wait for splash to clear (`sleep 5`), then send bare `Enter` |
| Claude idle detection never settles | Footer lines (branch, context %, bypass mode) change constantly — poll for expected response content strings instead of hash-based idle |

## Best Practices

1. Always launch shell first (zsh or bash)
2. Use `wait_idle` instead of sleep for timing
3. Capture output before killing panes
4. Use `-S -N` with capture-pane for long outputs (e.g., `-S -500` for 500 lines)
5. Handle errors — check output for error patterns
6. Clean up panes when done
7. Use `tmux list-panes` to see all active panes
8. Quote pane targets: `tmux send-keys -t "$PANE"` (targets contain colons/dots)

**Session Scratch (T1)**: mcp__plugin_conexus_nexus__scratch(action="put", content="..." to note interactive session findings (pane IDs, interim output, working hypotheses). Flagged items auto-promote to T2 at session end.

Wersje

W bazie nie ma innych skilli o nazwie cli-controller.

Migawka bazy z 13.11.2026 · wersja paczki 8f5e7889f9a3 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100jshell
    Pomaga uruchamiać fragmenty kodu Java w JShell oraz używać JShell jako REPL i brudnopisu.
  • 100nodejs-python-interactive-debugger-pdb-ndb
    Debuguje na żywo procesy backendów Python i Node.js przez pdb, ipdb i ndb.
  • 100pwndbg
    Prowadzi debugowanie programu w GDB przez pwndbg MCP: rejestry, pamięć, stos i lokalizację awarii na zdalnej maszynie.
  • 95using-tmux-for-interactive-commands
    Steruje interaktywnymi narzędziami CLI, takimi jak vim, git rebase -i czy REPL Pythona, przez odłączone sesje tmux.
  • 95gdb
    Prowadzi debugowanie w GDB: punkty przerwania, obserwatory, awarie segmentacji, zawieszenia, zdalny gdbserver i pliki zrzutów.
  • 100clojure-repl
    Pracuje z działającymi REPL-ami Clojure przez nREPL: wykonuje kod, odpytuje przestrzenie nazw, testuje funkcje i debuguje żywe systemy w plikach .clj, .cljc i .cljs.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.