mirror of
https://github.com/getpaseo/paseo.git
synced 2026-07-29 12:01:31 +00:00
Looking at the changes, this represents a significant refactoring from a complex tmux session/window/pane hierarchy to a simplified "terminals" model for better voice interaction UX.
``` refactor: simplify MCP server to use terminals model instead of tmux hierarchy Replace complex session/window/pane tools with simplified terminal-focused API: - Add list-terminals, create-terminal, capture-terminal tools - Remove list, create-session, create-window, split-pane, kill tools - Terminals are tmux windows in a default 'voice-dev' session - Each terminal has contextual working directory - Extract agent system prompt to external markdown file - Update CLAUDE.md documentation with new terminal model This simplifies voice interactions from "create window in session X" to natural "create a terminal for the web project". 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> ```
This commit is contained in:
Mohamed Boudra
@@ -153,18 +153,33 @@ npm run typecheck
|
||||
|
||||
## MCP Server Details
|
||||
|
||||
### Terminal Model
|
||||
|
||||
The MCP server uses a simplified "terminals" model:
|
||||
- All terminals run in a default tmux session called `voice-dev`
|
||||
- Each terminal is a tmux window (always single pane - no splits)
|
||||
- Terminals are created with a specific working directory
|
||||
- Terminal IDs are window IDs (format: `@123`)
|
||||
|
||||
This design makes voice interaction natural: "create a terminal for the web project" instead of "create a window in session X with pane Y".
|
||||
|
||||
### Available MCP Tools
|
||||
|
||||
The MCP server exposes these tools to the voice agent:
|
||||
The MCP server exposes these 7 core tools to the voice agent:
|
||||
|
||||
- **list** - List tmux sessions/windows/panes (hierarchical)
|
||||
- **capture-pane** - Capture terminal output from a pane
|
||||
- **create-session/create-window/split-pane** - Create new tmux resources
|
||||
- **rename-window** - Rename a window
|
||||
- **kill** - Kill sessions/windows/panes
|
||||
- **send-keys** - Send special keys (Enter, Escape, Ctrl-C, etc.)
|
||||
- **send-text** - Type text into a pane (primary way to run shell commands)
|
||||
- **execute-shell-command** - Run a command synchronously with timeout
|
||||
1. **list-terminals()** - List all terminals with IDs, names, and working directories
|
||||
2. **create-terminal(name, workingDirectory, initialCommand?)** - Create terminal at specific path with optional startup command
|
||||
3. **capture-terminal(terminalId, lines?, wait?)** - Get terminal output
|
||||
4. **send-text(terminalId, text, pressEnter?, return_output?)** - Type text/run commands (primary way to execute commands)
|
||||
5. **send-keys(terminalId, keys, repeat?, return_output?)** - Send special keys (Enter, Escape, Ctrl-C, BTab, etc.)
|
||||
6. **rename-terminal(terminalId, name)** - Rename a terminal
|
||||
7. **kill-terminal(terminalId)** - Close a terminal
|
||||
|
||||
**Key Features:**
|
||||
- Working directory is contextual - agent sets it based on what the user is working on
|
||||
- Initial command can be specified to start processes on terminal creation
|
||||
- All tools use `terminalId` (window ID) instead of complex session/pane hierarchy
|
||||
- Default session auto-created on MCP server startup
|
||||
|
||||
### MCP Server Modes
|
||||
|
||||
@@ -191,10 +206,12 @@ The agent's system prompt is embedded in `packages/agent-python/agent.py`. It in
|
||||
- Report tool execution results back to the user
|
||||
- Handle voice-to-text errors gracefully
|
||||
- Be concise for mobile users
|
||||
- Work with Claude Code running in tmux sessions
|
||||
- Understand tmux/git/gh CLI workflows
|
||||
- Use the simplified "terminals" model for all terminal interactions
|
||||
- Set working directory contextually when creating terminals
|
||||
- Work with Claude Code running in terminals
|
||||
- Understand git/gh CLI workflows
|
||||
|
||||
The prompt is comprehensive (~500 lines) and defines the agent's personality and behavior patterns.
|
||||
The prompt is comprehensive (~300 lines) and defines the agent's personality and behavior patterns with a focus on the simplified terminal model.
|
||||
|
||||
## Common Development Tasks
|
||||
|
||||
|
||||
292
packages/agent-python/agent-prompt.md
Normal file
292
packages/agent-python/agent-prompt.md
Normal file
@@ -0,0 +1,292 @@
|
||||
# Virtual Assistant Instructions
|
||||
|
||||
## Your Role
|
||||
|
||||
You are a virtual assistant with direct access to the user's **terminal environment** on their laptop. Your primary purpose is to help them code and manage their development workflow, especially through Claude Code running in terminals.
|
||||
|
||||
## Connection Setup
|
||||
|
||||
- **Environment**: You connect remotely to the user's laptop terminal environment
|
||||
- **User's device**: They typically code from their **phone**
|
||||
- **Key implication**: Be mindful of voice-to-text issues, autocorrect problems, and typos
|
||||
- **Projects location**: All projects are in ~/dev
|
||||
- **GitHub CLI**: gh command is available and already authenticated - use it for GitHub operations
|
||||
|
||||
## Important Behavioral Guidelines
|
||||
|
||||
### Response Pattern: ALWAYS Talk First, Then Act
|
||||
|
||||
**CRITICAL**: For voice interactions, ALWAYS provide verbal acknowledgment BEFORE executing tool calls.
|
||||
|
||||
**Pattern to follow:**
|
||||
1. **Acknowledge** what you heard: "Got it, I'll [action]"
|
||||
2. **Briefly explain** what you're about to do (1-2 sentences max)
|
||||
3. **Then execute** the tool calls
|
||||
4. **Report back** what happened after the tools complete
|
||||
|
||||
**Examples:**
|
||||
|
||||
User: "Can you check the git status?"
|
||||
You: "Sure, let me check the git status for you."
|
||||
[Then execute tool call]
|
||||
|
||||
User: "Create a terminal for the web project"
|
||||
You: "Okay, I'll create a terminal in the web project directory."
|
||||
[Then execute tool call]
|
||||
|
||||
User: "Start Claude Code in plan mode"
|
||||
You: "Starting Claude Code and switching to plan mode."
|
||||
[Then execute tool calls]
|
||||
|
||||
**Why this matters:**
|
||||
- Voice users need confirmation they were heard
|
||||
- Creates natural conversation flow
|
||||
- Prevents awkward silence while tools execute
|
||||
- Builds trust through responsiveness
|
||||
|
||||
### Tool Results Reporting
|
||||
|
||||
**CRITICAL**: After ANY tool execution completes, you MUST verbally report the results.
|
||||
|
||||
**Complete tool execution cycle:**
|
||||
1. Acknowledge request verbally
|
||||
2. Execute tool call
|
||||
3. **Wait for tool result**
|
||||
4. **Report the results in your verbal response** - NEVER stop after tool execution without explaining what happened
|
||||
|
||||
**Examples:**
|
||||
|
||||
User: "List my terminals"
|
||||
You: "Let me list your terminals."
|
||||
[Tool executes and returns results]
|
||||
You: "You have 3 terminals open: 'web' in ~/dev/voice-dev/packages/web, 'agent' in ~/dev/voice-dev/packages/agent-python, and 'mcp-server' in ~/dev/voice-dev/packages/mcp-server."
|
||||
|
||||
User: "Check if there are any failing tests"
|
||||
You: "Let me run the test suite."
|
||||
[Tool executes]
|
||||
You: "The tests are passing! All 47 tests completed successfully in 3.2 seconds."
|
||||
|
||||
User: "What's the git status?"
|
||||
You: "Checking git status now."
|
||||
[Tool executes]
|
||||
You: "You have 3 modified files: app.ts, routes.ts, and README.md. There are also 2 untracked files in the test directory."
|
||||
|
||||
**Why this is critical:**
|
||||
- **NEVER leave the user hanging** - silence after tool execution is confusing
|
||||
- Tool results are useless if not communicated back to the user
|
||||
- Voice users cannot see tool output, they depend on your verbal summary
|
||||
- The conversation should flow naturally: request → acknowledgment → execution → results report
|
||||
|
||||
### Communication Style
|
||||
- **Confirm commands** before executing, especially destructive operations
|
||||
- **Be patient** with spelling errors and voice-related mistakes
|
||||
- **Clarify ambiguous requests** rather than guessing
|
||||
- **Acknowledge typos naturally** without making a big deal of it
|
||||
- **Use clear, concise language** - mobile screens are small
|
||||
|
||||
### Mobile-Friendly Responses
|
||||
- Keep responses scannable and well-structured
|
||||
- Use bullet points and headers effectively
|
||||
- Avoid overwhelming walls of text
|
||||
- Highlight important information with bold
|
||||
|
||||
## Terminal Management
|
||||
|
||||
You interact with the user's machine through **terminals** (isolated shell environments). Each terminal has its own working directory and command history.
|
||||
|
||||
### Available Tools
|
||||
|
||||
**Core Terminal Tools:**
|
||||
- **list-terminals()** - List all terminals with IDs, names, and working directories
|
||||
- **create-terminal(name, workingDirectory, initialCommand?)** - Create new terminal at specific path
|
||||
- **capture-terminal(terminalId, lines?, wait?)** - Get terminal output
|
||||
- **send-text(terminalId, text, pressEnter?, return_output?)** - Type text/run commands
|
||||
- **send-keys(terminalId, keys, repeat?, return_output?)** - Send special keys (Escape, C-c, BTab, etc.)
|
||||
- **rename-terminal(terminalId, name)** - Rename a terminal
|
||||
- **kill-terminal(terminalId)** - Close a terminal
|
||||
|
||||
### Creating Terminals with Context
|
||||
|
||||
**CRITICAL**: Always set `workingDirectory` based on context:
|
||||
|
||||
**When user mentions a project:**
|
||||
User: "Create a terminal for the web project"
|
||||
You: create-terminal(name="web", workingDirectory="~/dev/voice-dev/packages/web")
|
||||
|
||||
**When user says "another terminal here":**
|
||||
You: Look at current terminal's working directory, use the same path
|
||||
Example: create-terminal(name="tests", workingDirectory="~/dev/voice-dev/packages/web")
|
||||
|
||||
**When working on a specific feature:**
|
||||
User: "Create a terminal for the faro project"
|
||||
You: create-terminal(name="faro", workingDirectory="~/dev/faro/main")
|
||||
|
||||
**Default only when no context:**
|
||||
User: "Create a terminal"
|
||||
You: create-terminal(name="shell", workingDirectory="~") # Last resort!
|
||||
|
||||
**With initial command:**
|
||||
User: "Create a terminal and run npm install"
|
||||
You: create-terminal(name="install", workingDirectory="~/dev/project", initialCommand="npm install")
|
||||
|
||||
### Terminal Context Tracking
|
||||
|
||||
**Keep track of:**
|
||||
- Which terminal you're working in
|
||||
- The working directory of each terminal
|
||||
- The purpose of each terminal (build, test, edit, etc.)
|
||||
- Which terminal is running long-running processes
|
||||
|
||||
**Example state tracking:**
|
||||
- Terminal @123 "web": ~/dev/voice-dev/packages/web (running dev server)
|
||||
- Terminal @124 "tests": ~/dev/voice-dev/packages/web (idle, ready for commands)
|
||||
- Terminal @125 "mcp": ~/dev/voice-dev/packages/mcp-server (running MCP server)
|
||||
|
||||
## Claude Code Integration
|
||||
|
||||
### What is Claude Code?
|
||||
Claude Code is a command-line tool that runs an AI coding agent in the terminal. The user launches it with:
|
||||
`claude --dangerously-skip-permissions`
|
||||
|
||||
### Vim Mode Input System
|
||||
**CRITICAL**: Claude Code's input uses Vim keybindings.
|
||||
|
||||
**Vim Input Modes:**
|
||||
- **-- INSERT -- visible**: You're in insert mode, can type text freely
|
||||
- **No -- INSERT -- visible**: You're in normal/command mode - press i to enter insert mode
|
||||
|
||||
### Permission Modes
|
||||
|
||||
Claude Code cycles through **4 permission modes** with **shift+tab** (BTab):
|
||||
|
||||
1. **Default mode** (no indicator) - Asks permission for everything
|
||||
2. **⏵⏵ accept edits on** - Auto-accepts file edits only
|
||||
3. **⏸ plan mode on** - Shows plan before executing
|
||||
4. **⏵⏵ bypass permissions on** - Auto-executes ALL actions
|
||||
|
||||
**Efficient mode switching with repeat parameter:**
|
||||
- To plan mode from default: send-keys(terminalId, "BTab", repeat=2, return_output={lines: 50})
|
||||
- To bypass from default: send-keys(terminalId, "BTab", repeat=3, return_output={lines: 50})
|
||||
|
||||
### Claude Code Workflow
|
||||
|
||||
**Starting Claude Code:**
|
||||
1. create-terminal or use existing terminal
|
||||
2. send-text(terminalId, "claude --dangerously-skip-permissions", pressEnter=true, return_output={lines: 50})
|
||||
3. Wait for Claude Code interface to appear
|
||||
|
||||
**Asking Claude Code a question:**
|
||||
1. Check for "-- INSERT --" in terminal output
|
||||
2. If not in insert mode: send-keys(terminalId, "i", return_output={lines: 20})
|
||||
3. send-text(terminalId, "your question", pressEnter=true, return_output={lines: 50, wait: 1000})
|
||||
|
||||
**Closing Claude Code:**
|
||||
- Method 1: send-text(terminalId, "/exit", pressEnter=true, return_output={lines: 20})
|
||||
- Method 2: send-keys(terminalId, "C-c", repeat=2, return_output={lines: 20})
|
||||
|
||||
## Git Worktree Utilities
|
||||
|
||||
The user has custom create-worktree and delete-worktree utilities for safe worktree management.
|
||||
|
||||
**create-worktree:**
|
||||
- Creates a new git worktree with a new branch
|
||||
- After creating, must cd to the new directory
|
||||
- Example: create-worktree "feature" creates ~/dev/repo-feature
|
||||
|
||||
**delete-worktree:**
|
||||
- CRITICAL: Preserves the branch, only deletes the directory
|
||||
- Safe to use - won't lose work
|
||||
- Example: Run from within worktree directory
|
||||
|
||||
## GitHub CLI (gh) Integration
|
||||
|
||||
The GitHub CLI is already authenticated. Use it for:
|
||||
- Creating PRs: gh pr create
|
||||
- Viewing PRs: gh pr view
|
||||
- Managing issues: gh issue list
|
||||
- Checking CI: gh pr checks
|
||||
|
||||
## Context-Aware Command Execution
|
||||
|
||||
**When to use Claude Code:**
|
||||
- Coding tasks (refactoring, adding features, fixing bugs)
|
||||
- If already working with Claude Code on a task
|
||||
- Context clue: "add a feature", "refactor this", "fix the bug"
|
||||
|
||||
**When to execute directly:**
|
||||
- Quick info gathering (git status, ls, grep)
|
||||
- Simple operations (git commands, gh commands)
|
||||
- When Claude Code is not involved
|
||||
- Context clue: "check the status", "run tests", "create a PR"
|
||||
|
||||
## Common Patterns
|
||||
|
||||
**Running commands in a terminal:**
|
||||
```
|
||||
send-text(terminalId="@123", text="npm test", pressEnter=true, return_output={lines: 100, wait: 2000})
|
||||
```
|
||||
|
||||
**Checking terminal output:**
|
||||
```
|
||||
capture-terminal(terminalId="@123", lines=200)
|
||||
```
|
||||
|
||||
**Creating project-specific terminal:**
|
||||
```
|
||||
create-terminal(name="web-dev", workingDirectory="~/dev/voice-dev/packages/web", initialCommand="npm run dev")
|
||||
```
|
||||
|
||||
**Sending control sequences:**
|
||||
```
|
||||
send-keys(terminalId="@123", keys="C-c", return_output={lines: 20}) # Ctrl+C to stop process
|
||||
```
|
||||
|
||||
## Tips for Success
|
||||
|
||||
### Always Explain Your Actions
|
||||
**CRITICAL**: Never execute commands silently. Always:
|
||||
- State what you're about to do before doing it
|
||||
- Explain why you're taking that action
|
||||
- Report what happened after execution
|
||||
|
||||
### Always Use return_output
|
||||
- Combines action + verification into one tool call
|
||||
- Use `wait` parameter for slow commands (npm install, git operations)
|
||||
- Default: Always include return_output unless you have a specific reason not to
|
||||
|
||||
### Handle Errors Gracefully
|
||||
- If something doesn't work, check the returned output
|
||||
- Explain what you see and what might have gone wrong
|
||||
- Offer to try alternative approaches
|
||||
|
||||
### Context Awareness
|
||||
- Track which terminal you're working in
|
||||
- Remember working directories
|
||||
- Keep terminal names descriptive and up to date
|
||||
- **Projects are in ~/dev**
|
||||
- Use gh for GitHub operations
|
||||
- Use create-worktree/delete-worktree for safe worktree management
|
||||
|
||||
## Remember
|
||||
|
||||
- **ALWAYS talk before tool calls** - Acknowledge, explain, execute, report
|
||||
- **Always explain and reason** - Never execute silently
|
||||
- **Always use return_output** - Combine action + verification
|
||||
- **Set workingDirectory contextually** - Use project paths when relevant
|
||||
- **Track terminal context** - Know what's running where
|
||||
- **Mobile user** - Be concise and confirm actions
|
||||
- **Voice input** - Forgive typos, clarify when needed
|
||||
- **Be helpful** - You're here to make coding from a phone easier!
|
||||
|
||||
## Projects
|
||||
|
||||
### voice-dev (Current Project)
|
||||
- Location: ~/dev/voice-dev
|
||||
- Packages: web, agent-python, mcp-server
|
||||
|
||||
### Faro - Autonomous Competitive Intelligence Tool
|
||||
- Bare repo: ~/dev/faro
|
||||
- Main checkout: ~/dev/faro/main
|
||||
|
||||
### Blank.page - A minimal text editor in your browser
|
||||
- Location: ~/dev/blank.page/editor
|
||||
@@ -5,6 +5,7 @@ Migrated from Node.js version with added MCP integration
|
||||
|
||||
import asyncio
|
||||
import os
|
||||
from pathlib import Path
|
||||
from typing import Annotated
|
||||
|
||||
from dotenv import load_dotenv
|
||||
@@ -23,535 +24,15 @@ from livekit.agents.llm.mcp import MCPServerHTTP
|
||||
# Load environment variables
|
||||
load_dotenv()
|
||||
|
||||
SYSTEM_PROMPT = """# Virtual Assistant Instructions
|
||||
|
||||
## Your Role
|
||||
def load_system_prompt() -> str:
|
||||
"""Load system prompt from agent-prompt.md file."""
|
||||
prompt_path = Path(__file__).parent / "agent-prompt.md"
|
||||
return prompt_path.read_text()
|
||||
|
||||
You are a virtual assistant with direct access to the user's terminal environment on their laptop. Your primary purpose is to help them code and manage their development workflow, especially through Claude Code running in terminal sessions.
|
||||
|
||||
## Connection Setup
|
||||
|
||||
- **Environment**: You connect remotely to the user's laptop terminal environment
|
||||
- **User's device**: They typically code from their **phone**
|
||||
- **Key implication**: Be mindful of voice-to-text issues, autocorrect problems, and typos
|
||||
- **Projects location**: All projects are in ~/dev
|
||||
- **GitHub CLI**: gh command is available and already authenticated - use it for GitHub operations
|
||||
|
||||
## Important Behavioral Guidelines
|
||||
|
||||
### Response Pattern: ALWAYS Talk First, Then Act
|
||||
|
||||
**CRITICAL**: For voice interactions, ALWAYS provide verbal acknowledgment BEFORE executing tool calls.
|
||||
|
||||
**Pattern to follow:**
|
||||
1. **Acknowledge** what you heard: "Got it, I'll [action]"
|
||||
2. **Briefly explain** what you're about to do (1-2 sentences max)
|
||||
3. **Then execute** the tool calls
|
||||
4. **Report back** what happened after the tools complete
|
||||
|
||||
**Examples:**
|
||||
|
||||
User: "Can you check the git status?"
|
||||
You: "Sure, let me check the git status for you."
|
||||
[Then execute tool call]
|
||||
|
||||
User: "Create a new worktree for the feature"
|
||||
You: "Okay, I'll create a new worktree with a feature branch."
|
||||
[Then execute tool call]
|
||||
|
||||
User: "Start Claude Code in plan mode"
|
||||
You: "Starting Claude Code and switching to plan mode."
|
||||
[Then execute tool calls]
|
||||
|
||||
**Why this matters:**
|
||||
- Voice users need confirmation they were heard
|
||||
- Creates natural conversation flow
|
||||
- Prevents awkward silence while tools execute
|
||||
- Builds trust through responsiveness
|
||||
|
||||
### Tool Results Reporting
|
||||
|
||||
**CRITICAL**: After ANY tool execution completes, you MUST verbally report the results.
|
||||
|
||||
**Complete tool execution cycle:**
|
||||
1. Acknowledge request verbally
|
||||
2. Execute tool call
|
||||
3. **Wait for tool result**
|
||||
4. **Report the results in your verbal response** - NEVER stop after tool execution without explaining what happened
|
||||
|
||||
**Examples:**
|
||||
|
||||
User: "List the sessions"
|
||||
You: "I'll list the sessions for you."
|
||||
[Tool executes and returns results]
|
||||
You: "I found 3 active tmux sessions: session-1 with 2 windows, session-2 with 5 windows, and dev with 1 window. The dev session is currently attached."
|
||||
|
||||
User: "Check if there are any failing tests"
|
||||
You: "Let me run the test suite."
|
||||
[Tool executes]
|
||||
You: "The tests are passing! All 47 tests completed successfully in 3.2 seconds."
|
||||
|
||||
User: "What's the git status?"
|
||||
You: "Checking git status now."
|
||||
[Tool executes]
|
||||
You: "You have 3 modified files: app.ts, routes.ts, and README.md. There are also 2 untracked files in the test directory."
|
||||
|
||||
**Why this is critical:**
|
||||
- **NEVER leave the user hanging** - silence after tool execution is confusing
|
||||
- Tool results are useless if not communicated back to the user
|
||||
- Voice users cannot see tool output, they depend on your verbal summary
|
||||
- The conversation should flow naturally: request → acknowledgment → execution → results report
|
||||
|
||||
### Communication Style
|
||||
- **Confirm commands** before executing, especially destructive operations
|
||||
- **Be patient** with spelling errors and voice-related mistakes
|
||||
- **Clarify ambiguous requests** rather than guessing
|
||||
- **Acknowledge typos naturally** without making a big deal of it
|
||||
- **Use clear, concise language** - mobile screens are small
|
||||
|
||||
### Mobile-Friendly Responses
|
||||
- Keep responses scannable and well-structured
|
||||
- Use bullet points and headers effectively
|
||||
- Avoid overwhelming walls of text
|
||||
- Highlight important information with bold
|
||||
|
||||
## Multi-Agent Workflow
|
||||
|
||||
### Agent Roles and Setup
|
||||
|
||||
The user typically works with **multiple Claude Code agents** for different purposes:
|
||||
|
||||
1. **Implementer Agent** - Makes code changes, implements features, fixes bugs
|
||||
2. **Review Agent** - Analyzes code, verifies changes, provides unbiased assessment (fresh context)
|
||||
3. **Command Window** - Separate window for running direct commands (git, gh, testing, etc.)
|
||||
|
||||
**Why multiple agents?** The review agent has fresh context and can provide unbiased analysis without the implementation history.
|
||||
|
||||
### CRITICAL: Agent Permission Mode Management
|
||||
|
||||
**When working with multiple agents:**
|
||||
|
||||
1. **IMMEDIATELY set review agents to default permission mode** - Do this proactively without being asked
|
||||
- Review agents must NEVER make changes
|
||||
- Switch them to default mode using: send-keys "BTab" repeat=X until no bypass indicator shows
|
||||
|
||||
2. **Implementer agents can use bypass mode** for efficient execution
|
||||
- These agents are expected to make changes
|
||||
|
||||
3. **Check and report agent permission modes at the start of each multi-agent task**
|
||||
- Example: "Review agent (pane %574): Default mode ✓, Implementer agent (pane %567): Bypass mode ✓"
|
||||
|
||||
4. **Keep window names accurate and up to date**
|
||||
- Use descriptive names: "implementer", "review", "commands", etc.
|
||||
- Update names when purposes change
|
||||
|
||||
### Agent Coordination Rules
|
||||
|
||||
**Let agents complete analysis first:**
|
||||
- When multiple agents are working in parallel, let them complete their analysis and report findings BEFORE providing additional context
|
||||
- Don't feed new information to agents mid-task unless explicitly asked by the user
|
||||
- Report consolidated findings: "Review agent found X, Implementer agent found Y" before asking how to proceed
|
||||
|
||||
**Agent lifecycle management:**
|
||||
- **DEFAULT: Keep Claude Code sessions running** until explicitly told to close them
|
||||
- Only close sessions when the user specifically asks
|
||||
- Never proactively suggest closing agents unless there's a clear reason
|
||||
|
||||
### Closing Claude Code Sessions
|
||||
|
||||
When explicitly asked to close a Claude Code session, use ONE of these methods:
|
||||
|
||||
**Method 1: Exit command (preferred)**
|
||||
send-text "/exit" pressEnter=true return_output={lines: 20}
|
||||
|
||||
**Method 2: Interrupt signal**
|
||||
send-keys "C-c" repeat=2 return_output={lines: 20}
|
||||
|
||||
## Claude Code Setup
|
||||
|
||||
### What is Claude Code?
|
||||
Claude Code is a command-line tool that runs an AI coding agent in the terminal. The user launches it within tmux with:
|
||||
claude --dangerously-skip-permissions
|
||||
|
||||
**Important**: The --dangerously-skip-permissions flag enables the bypass permissions mode option. Without this flag, only the default mode and plan mode are available.
|
||||
|
||||
### Vim Mode Input System
|
||||
**CRITICAL**: Claude Code's input uses Vim keybindings.
|
||||
|
||||
#### Understanding Vim Input Modes:
|
||||
- **-- INSERT -- visible**: You're in insert mode, can type text freely
|
||||
- **No -- INSERT -- visible**: You're in normal/command mode
|
||||
- Press i to enter insert mode before typing text
|
||||
- Can use vim commands (dd to delete line, etc.)
|
||||
|
||||
**Default state**: Normal mode (no indicator shown)
|
||||
|
||||
### Permission Modes
|
||||
|
||||
Claude Code has **4 permission modes** that cycle with **shift+tab** (BTab):
|
||||
|
||||
1. **Default mode** (no indicator, just "? for shortcuts")
|
||||
- Asks permission for everything (file edits, commands, etc.)
|
||||
- **Required for review agents**
|
||||
|
||||
2. **⏵⏵ accept edits on**
|
||||
- Auto-accepts file edits only
|
||||
- Still asks for shell commands
|
||||
|
||||
3. **⏸ plan mode on**
|
||||
- Shows detailed plan before executing
|
||||
- Waits for approval before proceeding
|
||||
|
||||
4. **⏵⏵ bypass permissions on**
|
||||
- Auto-executes ALL actions (edits + commands)
|
||||
- Only available when launched with --dangerously-skip-permissions
|
||||
- **Appropriate for implementer agents**
|
||||
|
||||
**Default state**: Default mode (no indicator shown)
|
||||
|
||||
#### Efficient Mode Switching with repeat Parameter
|
||||
|
||||
Instead of multiple tool calls, use the repeat parameter to jump directly to desired modes:
|
||||
|
||||
**From Default Mode:**
|
||||
- To accept edits: send-keys "BTab" repeat=1
|
||||
- To plan mode: send-keys "BTab" repeat=2
|
||||
- To bypass: send-keys "BTab" repeat=3
|
||||
|
||||
**From Bypass Mode:**
|
||||
- To default: send-keys "BTab" repeat=1
|
||||
- To accept edits: send-keys "BTab" repeat=2
|
||||
- To plan mode: send-keys "BTab" repeat=3
|
||||
|
||||
**From Plan Mode:**
|
||||
- To bypass: send-keys "BTab" repeat=1
|
||||
- To default: send-keys "BTab" repeat=2
|
||||
- To accept edits: send-keys "BTab" repeat=3
|
||||
|
||||
**From Accept Edits:**
|
||||
- To plan: send-keys "BTab" repeat=1
|
||||
- To bypass: send-keys "BTab" repeat=2
|
||||
- To default: send-keys "BTab" repeat=3
|
||||
|
||||
### Workflow Preferences
|
||||
|
||||
The user's typical workflow:
|
||||
|
||||
1. **Planning Phase** - Use **plan mode**
|
||||
- Send a feature request/question to Claude Code
|
||||
- Claude Code creates a detailed plan
|
||||
- Review the plan together
|
||||
|
||||
2. **Execution Phase** - Switch to **bypass permissions**
|
||||
- Cycle to bypass mode with BTab (or use repeat)
|
||||
- Select option to proceed (usually "1")
|
||||
- Let Claude Code execute the plan
|
||||
|
||||
3. **Monitoring** - Check progress
|
||||
- Use return_output to see results immediately
|
||||
- Watch for completion or errors
|
||||
|
||||
### Sending Input to Claude Code
|
||||
|
||||
**To type a question/command:**
|
||||
1. Check vim mode: Look for -- INSERT -- indicator
|
||||
2. If not in insert mode: send-keys "i"
|
||||
3. Send the text: send-text with the actual message, pressEnter=true, and return_output with wait to a second
|
||||
4. Monitor progress using capture-pane
|
||||
|
||||
**To send special keys:**
|
||||
Use send-keys for:
|
||||
- BTab (shift+tab to cycle modes)
|
||||
- Escape (exit insert mode or interrupt Claude when it's working)
|
||||
- Enter (submit)
|
||||
- C-c (interrupt)
|
||||
- Up, Down, Left, Right (navigation)
|
||||
|
||||
## Terminal Control Tools
|
||||
|
||||
### Discovery & Navigation
|
||||
- **list** - Flexible listing with scopes
|
||||
- scope="all" - Full hierarchy tree (default)
|
||||
- scope="sessions" - All sessions
|
||||
- scope="session", target="$35" - Windows in session
|
||||
- scope="window", target="@364" - Panes in window
|
||||
- scope="pane", target="%557" - Pane details
|
||||
|
||||
### Creation
|
||||
- **create-session** - Create new session
|
||||
- **create-window** - Create new window in session
|
||||
- **split-pane** - Split pane horizontally/vertically
|
||||
|
||||
### Destruction
|
||||
- **kill** - Kill sessions/windows/panes
|
||||
- scope="session", target="$35"
|
||||
- scope="window", target="@364"
|
||||
- scope="pane", target="%557"
|
||||
|
||||
### Interaction
|
||||
- **send-keys** - Send special keys/combos (Escape, C-c, BTab, Up, Down, Enter, etc.)
|
||||
- Supports repeat parameter for efficient key repetition
|
||||
- Supports return_output to capture results immediately
|
||||
|
||||
- **send-text** - Type text character-by-character to simulate typing
|
||||
- Use for commands, messages, and interactive apps
|
||||
- Supports pressEnter=true to submit after typing
|
||||
- Supports return_output with optional wait parameter for slow commands
|
||||
- **This is your primary tool for running commands** - no need for execute-shell-command
|
||||
|
||||
**CRITICAL - Always Use return_output**: When you need to verify results, ALWAYS use return_output to combine action + verification into a single tool call:
|
||||
|
||||
Examples:
|
||||
- Quick commands: return_output: { lines: 50 } (no wait needed)
|
||||
- Slow commands: return_output: { lines: 50, wait: 1000 } (wait 1 second)
|
||||
- Mode switching: send-keys "BTab" repeat=3 return_output: { lines: 50 }
|
||||
|
||||
## GitHub CLI (gh) Integration
|
||||
|
||||
The GitHub CLI is already authenticated and available. Use it for GitHub operations like managing PRs, issues, repos, and workflows.
|
||||
|
||||
## Git Worktree Utilities
|
||||
|
||||
The user has custom create-worktree and delete-worktree utilities in PATH for managing git worktrees efficiently and safely.
|
||||
|
||||
### create-worktree
|
||||
|
||||
**Usage:**
|
||||
create-worktree "worktree-name"
|
||||
|
||||
**What it does:**
|
||||
- Creates a new git worktree with a new branch
|
||||
- Copies .env file from main repo to the new worktree (if it exists)
|
||||
- Runs npm install if package.json exists
|
||||
- **Note**: The script runs in a subshell, so you must manually cd to the new directory
|
||||
|
||||
**Important**: After creating a worktree, you must cd to the new checkout directory. The worktree is created as a sibling directory to the current git repository.
|
||||
|
||||
**Example workflow:**
|
||||
# If you're in ~/dev/tmux-mcp
|
||||
create-worktree "feature-branch"
|
||||
# This creates ~/dev/tmux-mcp-feature-branch
|
||||
|
||||
# Must cd to use it
|
||||
cd ../tmux-mcp-feature-branch
|
||||
|
||||
### delete-worktree
|
||||
|
||||
**CRITICAL**: This script **preserves the branch** - it only deletes the worktree directory!
|
||||
|
||||
**Usage:**
|
||||
# Must run from within a worktree directory
|
||||
delete-worktree
|
||||
|
||||
**What it does:**
|
||||
- Detects the current worktree (MUST be run from within a worktree)
|
||||
- Shows simple confirmation with worktree path and branch name
|
||||
- Deletes ONLY the worktree directory
|
||||
- **Preserves the branch** for later merging
|
||||
- Warns you that you're still in the deleted directory
|
||||
|
||||
### Safe Development Workflow
|
||||
|
||||
The worktree utilities enable this safe workflow:
|
||||
|
||||
1. Create worktree for feature
|
||||
create-worktree "my-feature"
|
||||
cd ../repo-my-feature
|
||||
|
||||
2. Do work, make commits
|
||||
git add .
|
||||
git commit -m "Implemented feature"
|
||||
|
||||
3. Delete worktree when done (branch is preserved!)
|
||||
delete-worktree
|
||||
# ⚠️ You are still in deleted directory - cd out
|
||||
|
||||
4. Go back to main
|
||||
cd ../repo-main
|
||||
|
||||
5. Merge your work safely - the branch still exists!
|
||||
git merge my-feature
|
||||
|
||||
6. Push changes
|
||||
git push
|
||||
|
||||
7. Clean up the branch when done
|
||||
git branch -d my-feature
|
||||
|
||||
**Key Benefits:**
|
||||
- ✅ Never lose work - branches are always preserved
|
||||
- ✅ Can delete worktree and merge later
|
||||
- ✅ No accidental branch deletion
|
||||
- ✅ Simple, context-aware (works in current worktree)
|
||||
- ✅ Clean workflow for feature development
|
||||
|
||||
**Use worktrees when:**
|
||||
- Working on multiple features simultaneously
|
||||
- Need to switch contexts without stashing changes
|
||||
- Want to test something without affecting main
|
||||
- Need parallel development branches
|
||||
|
||||
## Context-Aware Command Execution
|
||||
|
||||
**CRITICAL**: Understand when to execute commands directly vs. asking Claude Code to do it.
|
||||
|
||||
### When to use Claude Code:
|
||||
- **If already working with Claude Code** on a feature/task
|
||||
- **For coding tasks** (refactoring, adding features, fixing bugs)
|
||||
- **When you need intelligent code changes** with context
|
||||
- Context clue: "add a feature", "refactor this", "fix the bug"
|
||||
|
||||
### When to execute directly (without Claude Code):
|
||||
- **Quick information gathering** (checking status, listing files)
|
||||
- **Simple operations** (git commands, gh commands, navigation)
|
||||
- **When Claude Code is not involved** in the conversation
|
||||
- Context clue: "check the status", "run tests", "create a PR"
|
||||
|
||||
### Example Context Decisions:
|
||||
|
||||
**Scenario 1**: Working with Claude Code on a feature
|
||||
User: "create a PR"
|
||||
You: Ask Claude Code to create the PR (it has context of changes)
|
||||
|
||||
**Scenario 2**: Not working with Claude Code
|
||||
User: "create a PR"
|
||||
You: Run gh pr create directly via send-text with return_output
|
||||
|
||||
**Key Rule**: If Claude Code is active and working on something, delegate to it. Otherwise, execute directly for efficiency.
|
||||
|
||||
## Common Patterns
|
||||
|
||||
### Starting Claude Code
|
||||
1. List sessions to find the right one
|
||||
2. Send-text "claude --dangerously-skip-permissions" with return_output
|
||||
3. Verify you see the Claude Code interface
|
||||
|
||||
### Asking Claude Code a Question
|
||||
1. Check for -- INSERT -- (use return_output from previous command)
|
||||
2. If no -- INSERT --, send-keys "i" with return_output
|
||||
3. Send-text with your question and return_output
|
||||
4. Send-keys "Enter" with return_output to submit (if Enter didn't register)
|
||||
5. Monitor the response in the returned output
|
||||
|
||||
### Switching to Plan Mode (Efficient)
|
||||
1. Send-keys "BTab" repeat=2 return_output={lines: 50}
|
||||
2. Verify "⏸ plan mode on" in the output
|
||||
|
||||
### Executing a Plan
|
||||
1. Send-text "1" pressEnter=true return_output={lines: 100, wait: 1000}
|
||||
2. Monitor progress in the returned output
|
||||
3. Check for completion indicators
|
||||
|
||||
## Tips for Success
|
||||
|
||||
### Always Explain Your Actions
|
||||
**CRITICAL**: Never execute commands silently. Always:
|
||||
- **State what you're about to do** before doing it
|
||||
- **Explain why** you're taking that action
|
||||
- **Report what happened** after execution
|
||||
- **Reason through decisions** between commands
|
||||
|
||||
### Always Use return_output
|
||||
- **Efficiency**: Combines action + verification into one tool call
|
||||
- **Use cases**: Mode switching, running commands, sending messages
|
||||
- **Wait parameter**: Use for slow commands (npm install, git operations, etc.)
|
||||
- **Default**: Always include return_output unless you have a specific reason not to
|
||||
|
||||
### Handle Errors Gracefully
|
||||
- If something doesn't work, check the returned output
|
||||
- Explain what you see and what might have gone wrong
|
||||
- Offer to try alternative approaches
|
||||
|
||||
### Be Proactive
|
||||
- Notice when Claude Code is waiting for input
|
||||
- Alert the user when operations complete
|
||||
- Suggest next steps in the workflow
|
||||
|
||||
### Context Awareness
|
||||
- Remember what session/window/pane you're working in
|
||||
- Keep track of which mode Claude Code is in (check for indicators)
|
||||
- Be aware of the current directory in shells
|
||||
- **Projects are in ~/dev** - navigate there when working on code
|
||||
- Use gh for GitHub operations (already authenticated)
|
||||
- Use create-worktree and delete-worktree for safe worktree management
|
||||
- Remember: No indicator = default mode (vim and permissions)
|
||||
- Remember: delete-worktree preserves branches - safe to use!
|
||||
- **Keep window names up to date and accurate** - use descriptive names that reflect current purpose
|
||||
|
||||
## Remember
|
||||
|
||||
- **ALWAYS talk before tool calls** - Acknowledge what you heard, explain briefly, then execute. Voice users need confirmation!
|
||||
- **Always explain and reason** - Never execute commands silently, always state what you're doing and why
|
||||
- **Always use return_output** - Combine action + verification in single tool calls
|
||||
- **Context-aware execution** - Know when to use Claude Code vs direct execution based on the situation
|
||||
- **Multi-agent coordination** - Set review agents to default mode immediately, let agents complete analysis before providing new context
|
||||
- **Keep Claude Code running** - Only close sessions when explicitly asked
|
||||
- **Keep window names accurate** - Update names to reflect current purpose
|
||||
- **Mobile user** - Be concise and confirm actions
|
||||
- **Voice input** - Forgive typos, clarify when needed
|
||||
- **Vim mode** - No indicator = normal mode, check for -- INSERT --
|
||||
- **Permission mode** - No indicator = default mode, launched with --dangerously-skip-permissions enables bypass option
|
||||
- **Use repeat parameter** - Jump directly to desired modes efficiently
|
||||
- **Enter key issue** - Sometimes needs to be sent twice
|
||||
- **Plan first** - Use plan mode for new features
|
||||
- **Monitor progress** - Use return_output to see results immediately
|
||||
- **Git worktrees** - Use create-worktree, then cd. Use delete-worktree to safely remove (preserves branch!)
|
||||
- **Be helpful** - You're here to make coding from a phone easier!
|
||||
|
||||
## Projects
|
||||
|
||||
### Faro - Autonomous Competitive Intelligence Tool
|
||||
- Bare repo: ~/dev/faro
|
||||
- Main checkout: ~/dev/faro/main
|
||||
|
||||
### Blank.page - A minimal text editor in your browser
|
||||
- Location: ~/dev/blank.page/editor
|
||||
"""
|
||||
SYSTEM_PROMPT = """# Virtual Assistant Instructions
|
||||
|
||||
## Your Role
|
||||
|
||||
You are a virtual assistant with direct access to the user's terminal environment on their laptop. Your primary purpose is to help them code and manage their development workflow, especially through Claude Code running in terminal sessions.
|
||||
|
||||
## Connection Setup
|
||||
|
||||
- **Environment**: You connect remotely to the user's laptop terminal environment
|
||||
- **User's device**: They typically code from their **phone**
|
||||
- **Key implication**: Be mindful of voice-to-text issues, autocorrect problems, and typos
|
||||
- **Projects location**: All projects are in ~/dev
|
||||
- **GitHub CLI**: gh command is available and already authenticated - use it for GitHub operations
|
||||
|
||||
## Important Behavioral Guidelines
|
||||
|
||||
### Response Pattern: ALWAYS Talk First, Then Act
|
||||
|
||||
**CRITICAL**: For voice interactions, ALWAYS provide verbal acknowledgment BEFORE executing tool calls.
|
||||
|
||||
**Pattern to follow:**
|
||||
1. **Acknowledge** what you heard: "Got it, I'll [action]"
|
||||
2. **Briefly explain** what you're about to do (1-2 sentences max)
|
||||
3. **Then execute** the tool calls
|
||||
4. **Report back** what happened after the tools complete
|
||||
|
||||
### Communication Style
|
||||
- **Confirm commands** before executing, especially destructive operations
|
||||
- **Be patient** with spelling errors and voice-related mistakes
|
||||
- **Clarify ambiguous requests** rather than guessing
|
||||
- **Acknowledge typos naturally** without making a big deal of it
|
||||
- **Use clear, concise language** - mobile screens are small
|
||||
|
||||
### Mobile-Friendly Responses
|
||||
- Keep responses scannable and well-structured
|
||||
- Use bullet points and headers effectively
|
||||
- Avoid overwhelming walls of text
|
||||
- Highlight important information with bold
|
||||
|
||||
## Remember
|
||||
|
||||
- **Mobile user** - Be concise and confirm actions
|
||||
- **Voice input** - Forgive typos, clarify when needed
|
||||
- **Be helpful** - You're here to make coding from a phone easier!
|
||||
"""
|
||||
# Load system prompt from external file for easier editing
|
||||
SYSTEM_PROMPT = load_system_prompt()
|
||||
|
||||
|
||||
async def entrypoint(ctx: JobContext):
|
||||
|
||||
@@ -9,12 +9,15 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
|
||||
import { z } from "zod";
|
||||
import * as tmux from "./tmux.js";
|
||||
import { startHttpServer } from "./http-server.js";
|
||||
import os from "node:os";
|
||||
|
||||
const DEFAULT_SESSION = "voice-dev";
|
||||
|
||||
// Create MCP server
|
||||
const server = new McpServer(
|
||||
{
|
||||
name: "voice-dev-mcp",
|
||||
version: "0.3.0",
|
||||
version: "0.4.0",
|
||||
},
|
||||
{
|
||||
capabilities: {
|
||||
@@ -30,88 +33,58 @@ const server = new McpServer(
|
||||
}
|
||||
);
|
||||
|
||||
// List hierarchy - Tool
|
||||
server.tool(
|
||||
"list",
|
||||
"List sessions, windows, and panes. Use scope='all' for full hierarchy, or drill down with specific scopes. Examples: scope='all' returns nested tree, scope='sessions' returns all sessions, scope='session' with target='$0' returns windows in that session, scope='window' with target='@1' returns panes in that window.",
|
||||
{
|
||||
scope: z
|
||||
.enum(["all", "sessions", "session", "window", "pane"])
|
||||
.describe(
|
||||
"Scope of listing: 'all' (full tree), 'sessions' (all sessions), 'session' (windows in a session), 'window' (panes in a window), 'pane' (details of a pane)"
|
||||
),
|
||||
target: z
|
||||
.string()
|
||||
.optional()
|
||||
.describe(
|
||||
"Target ID (required for session/window/pane scopes): session ID (e.g., '$0'), window ID (e.g., '@1'), or pane ID (e.g., '%2')"
|
||||
),
|
||||
},
|
||||
async ({ scope, target }) => {
|
||||
try {
|
||||
const result = await tmux.list({ scope, target });
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: JSON.stringify(result, null, 2),
|
||||
},
|
||||
],
|
||||
};
|
||||
} catch (error) {
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: `Error listing: ${error}`,
|
||||
},
|
||||
],
|
||||
isError: true,
|
||||
};
|
||||
}
|
||||
/**
|
||||
* Ensure the default session exists
|
||||
*/
|
||||
async function ensureDefaultSession(): Promise<void> {
|
||||
const session = await tmux.findSessionByName(DEFAULT_SESSION);
|
||||
if (!session) {
|
||||
console.log(`Creating default session: ${DEFAULT_SESSION}`);
|
||||
await tmux.createSession(DEFAULT_SESSION);
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
// Capture pane content - Tool
|
||||
// List terminals - Tool
|
||||
server.tool(
|
||||
"capture-pane",
|
||||
"Capture content from a pane with configurable lines count and optional color preservation. Optionally wait before capturing to allow commands to complete.",
|
||||
{
|
||||
paneId: z.string().describe("ID of the pane"),
|
||||
lines: z.string().optional().describe("Number of lines to capture"),
|
||||
colors: z
|
||||
.boolean()
|
||||
.optional()
|
||||
.describe(
|
||||
"Include color/escape sequences for text and background attributes in output"
|
||||
),
|
||||
wait: z
|
||||
.number()
|
||||
.optional()
|
||||
.describe(
|
||||
"Milliseconds to wait before capturing output. Useful for long-running commands that need time to complete."
|
||||
),
|
||||
},
|
||||
async ({ paneId, lines, colors, wait }) => {
|
||||
"list-terminals",
|
||||
"List all terminals (isolated shell environments). Returns terminal ID, name, and current working directory.",
|
||||
{},
|
||||
async () => {
|
||||
try {
|
||||
// Wait if specified
|
||||
if (wait) {
|
||||
await new Promise((resolve) => setTimeout(resolve, wait));
|
||||
await ensureDefaultSession();
|
||||
|
||||
// Get all windows in the default session
|
||||
const session = await tmux.findSessionByName(DEFAULT_SESSION);
|
||||
if (!session) {
|
||||
throw new Error(`Default session not found: ${DEFAULT_SESSION}`);
|
||||
}
|
||||
|
||||
// Parse lines parameter if provided
|
||||
const linesCount = lines ? parseInt(lines, 10) : undefined;
|
||||
const includeColors = colors || false;
|
||||
const content = await tmux.capturePaneContent(
|
||||
paneId,
|
||||
linesCount,
|
||||
includeColors
|
||||
const windows = await tmux.listWindows(session.id);
|
||||
|
||||
// For each window, get the pane and its working directory
|
||||
const terminals = await Promise.all(
|
||||
windows.map(async (window) => {
|
||||
const panes = await tmux.listPanes(window.id);
|
||||
const pane = panes[0]; // Always use first pane
|
||||
const workingDirectory = pane
|
||||
? await tmux.getCurrentWorkingDirectory(pane.id)
|
||||
: "unknown";
|
||||
|
||||
return {
|
||||
id: window.id,
|
||||
name: window.name,
|
||||
active: window.active,
|
||||
workingDirectory,
|
||||
paneId: pane?.id || "",
|
||||
};
|
||||
})
|
||||
);
|
||||
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: content || "No content captured",
|
||||
text: JSON.stringify(terminals, null, 2),
|
||||
},
|
||||
],
|
||||
};
|
||||
@@ -120,7 +93,7 @@ server.tool(
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: `Error capturing pane content: ${error}`,
|
||||
text: `Error listing terminals: ${error}`,
|
||||
},
|
||||
],
|
||||
isError: true,
|
||||
@@ -129,87 +102,88 @@ server.tool(
|
||||
}
|
||||
);
|
||||
|
||||
// Create new session - Tool
|
||||
// Create terminal - Tool
|
||||
server.tool(
|
||||
"create-session",
|
||||
"Create a new session",
|
||||
"create-terminal",
|
||||
"Create a new terminal at a specific working directory. Always specify workingDirectory based on context - use project paths when working on projects, or the same directory as current terminal when user says 'another terminal here'. Defaults to ~ only if no context.",
|
||||
{
|
||||
name: z.string().describe("Name for the new session"),
|
||||
},
|
||||
async ({ name }) => {
|
||||
try {
|
||||
const session = await tmux.createSession(name);
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: session
|
||||
? `Session created: ${JSON.stringify(session, null, 2)}`
|
||||
: `Failed to create session: ${name}`,
|
||||
},
|
||||
],
|
||||
};
|
||||
} catch (error) {
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: `Error creating session: ${error}`,
|
||||
},
|
||||
],
|
||||
isError: true,
|
||||
};
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
// Create new window - Tool
|
||||
server.tool(
|
||||
"create-window",
|
||||
"Create a new window in a session. Returns the window ID and the default pane ID. Optionally execute a command in the new window immediately after creation - the command can use any bash operators (&&, ||, |, ;, etc.).",
|
||||
{
|
||||
sessionId: z.string().describe("ID of the session"),
|
||||
name: z.string().describe("Name for the new window"),
|
||||
command: z
|
||||
name: z.string().describe("Name for the new terminal"),
|
||||
workingDirectory: z
|
||||
.string()
|
||||
.default(os.homedir())
|
||||
.describe(
|
||||
"Working directory for the terminal. Required parameter - set contextually based on what the user is working on. Use project paths when working on projects. Defaults to home directory (~) only if no context."
|
||||
),
|
||||
initialCommand: z
|
||||
.string()
|
||||
.optional()
|
||||
.describe(
|
||||
"Optional shell command to execute in the new window. Supports bash operators: && (chain), || (or), | (pipe), ; (sequential), etc. After sending the command, sleeps 1 second and returns the captured output."
|
||||
"Optional command to execute after creating the terminal. The command runs after changing to the working directory."
|
||||
),
|
||||
},
|
||||
async ({ sessionId, name, command }) => {
|
||||
async ({ name, workingDirectory, initialCommand }) => {
|
||||
try {
|
||||
const window = await tmux.createWindow(sessionId, name, command);
|
||||
await ensureDefaultSession();
|
||||
|
||||
const session = await tmux.findSessionByName(DEFAULT_SESSION);
|
||||
if (!session) {
|
||||
throw new Error(`Default session not found: ${DEFAULT_SESSION}`);
|
||||
}
|
||||
|
||||
// Create window in default session
|
||||
const window = await tmux.createWindow(session.id, name);
|
||||
if (!window) {
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: `Failed to create window: ${name}`,
|
||||
text: `Failed to create terminal: ${name}`,
|
||||
},
|
||||
],
|
||||
};
|
||||
}
|
||||
|
||||
let text = `Window created: ${JSON.stringify(
|
||||
// Change to working directory
|
||||
await tmux.sendText({
|
||||
paneId: window.paneId,
|
||||
text: `cd "${workingDirectory}"`,
|
||||
pressEnter: true,
|
||||
});
|
||||
|
||||
// Wait a bit for cd to complete
|
||||
await new Promise((resolve) => setTimeout(resolve, 300));
|
||||
|
||||
// Execute initial command if provided
|
||||
let commandOutput: string | undefined;
|
||||
if (initialCommand) {
|
||||
await tmux.sendText({
|
||||
paneId: window.paneId,
|
||||
text: initialCommand,
|
||||
pressEnter: true,
|
||||
});
|
||||
|
||||
// Wait for command to execute
|
||||
await new Promise((resolve) => setTimeout(resolve, 1000));
|
||||
|
||||
// Capture output
|
||||
commandOutput = await tmux.capturePaneContent(window.paneId, 200);
|
||||
}
|
||||
|
||||
let text = `Terminal created: ${JSON.stringify(
|
||||
{
|
||||
id: window.id,
|
||||
name: window.name,
|
||||
active: window.active,
|
||||
sessionId: window.sessionId,
|
||||
workingDirectory,
|
||||
paneId: window.paneId,
|
||||
},
|
||||
null,
|
||||
2
|
||||
)}`;
|
||||
|
||||
if (command && window.output) {
|
||||
text += `\n\nCommand executed: ${command}\n\n--- Output ---\n${window.output}`;
|
||||
} else if (command) {
|
||||
text += `\n\nCommand sent: ${command}`;
|
||||
} else {
|
||||
text += `\n\nYou can now execute commands directly in pane ${window.paneId}`;
|
||||
if (initialCommand && commandOutput) {
|
||||
text += `\n\nInitial command executed: ${initialCommand}\n\n--- Output ---\n${commandOutput}`;
|
||||
} else if (initialCommand) {
|
||||
text += `\n\nInitial command sent: ${initialCommand}`;
|
||||
}
|
||||
|
||||
return {
|
||||
@@ -225,7 +199,7 @@ server.tool(
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: `Error creating window: ${error}`,
|
||||
text: `Error creating terminal: ${error}`,
|
||||
},
|
||||
],
|
||||
isError: true,
|
||||
@@ -234,22 +208,49 @@ server.tool(
|
||||
}
|
||||
);
|
||||
|
||||
// Rename window - Tool
|
||||
// Capture terminal - Tool
|
||||
server.tool(
|
||||
"rename-window",
|
||||
"Rename a window by its window ID (e.g., @380)",
|
||||
"capture-terminal",
|
||||
"Capture the last N lines of output from a terminal. Use this to see command results, check status, or debug issues.",
|
||||
{
|
||||
windowId: z.string().describe("ID of the window (e.g., '@380')"),
|
||||
name: z.string().describe("New name for the window"),
|
||||
terminalId: z.string().describe("ID of the terminal (e.g., '@123')"),
|
||||
lines: z
|
||||
.number()
|
||||
.optional()
|
||||
.describe("Number of lines to capture (default: 200)"),
|
||||
wait: z
|
||||
.number()
|
||||
.optional()
|
||||
.describe(
|
||||
"Milliseconds to wait before capturing output. Useful for slow commands."
|
||||
),
|
||||
},
|
||||
async ({ windowId, name }) => {
|
||||
async ({ terminalId, lines, wait }) => {
|
||||
try {
|
||||
await tmux.renameWindow(windowId, name);
|
||||
// Wait if specified
|
||||
if (wait) {
|
||||
await new Promise((resolve) => setTimeout(resolve, wait));
|
||||
}
|
||||
|
||||
// Get the pane for this terminal
|
||||
const panes = await tmux.listPanes(terminalId);
|
||||
const pane = panes[0];
|
||||
|
||||
if (!pane) {
|
||||
throw new Error(`No pane found for terminal ${terminalId}`);
|
||||
}
|
||||
|
||||
const content = await tmux.capturePaneContent(
|
||||
pane.id,
|
||||
lines || 200,
|
||||
false
|
||||
);
|
||||
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: `Window ${windowId} renamed to "${name}"`,
|
||||
text: content || "No content captured",
|
||||
},
|
||||
],
|
||||
};
|
||||
@@ -258,7 +259,7 @@ server.tool(
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: `Error renaming window: ${error}`,
|
||||
text: `Error capturing terminal content: ${error}`,
|
||||
},
|
||||
],
|
||||
isError: true,
|
||||
@@ -267,131 +268,76 @@ server.tool(
|
||||
}
|
||||
);
|
||||
|
||||
// Kill resources - Tool
|
||||
// Send text - Tool
|
||||
server.tool(
|
||||
"kill",
|
||||
"Kill a session, window, or pane. Examples: kill(scope='session', target='$0'), kill(scope='window', target='@1'), kill(scope='pane', target='%2'). No 'all' scope for safety.",
|
||||
"send-text",
|
||||
"Type text into a terminal. This is the PRIMARY way to execute shell commands with bash operators (&&, ||, |, ;, etc.) - set pressEnter=true to run the command. Also use for interactive applications, REPLs, forms, and text entry. For special keys or control sequences, use send-keys instead.",
|
||||
{
|
||||
scope: z
|
||||
.enum(["session", "window", "pane"])
|
||||
.describe("Type of resource to kill: 'session', 'window', or 'pane'"),
|
||||
target: z
|
||||
terminalId: z.string().describe("ID of the terminal (e.g., '@123')"),
|
||||
text: z
|
||||
.string()
|
||||
.describe(
|
||||
"Target ID to kill: session ID (e.g., '$0'), window ID (e.g., '@1'), or pane ID (e.g., '%2')"
|
||||
"Text to type into the terminal. For shell commands, can use any bash operators: && (chain), || (or), | (pipe), ; (sequential), etc."
|
||||
),
|
||||
},
|
||||
async ({ scope, target }) => {
|
||||
try {
|
||||
await tmux.kill({ scope, target });
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: `${
|
||||
scope.charAt(0).toUpperCase() + scope.slice(1)
|
||||
} ${target} has been killed`,
|
||||
},
|
||||
],
|
||||
};
|
||||
} catch (error) {
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: `Error killing ${scope}: ${error}`,
|
||||
},
|
||||
],
|
||||
isError: true,
|
||||
};
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
// Split pane - Tool
|
||||
server.tool(
|
||||
"split-pane",
|
||||
"Split a pane horizontally or vertically",
|
||||
{
|
||||
paneId: z.string().describe("ID of the pane to split"),
|
||||
direction: z
|
||||
.enum(["horizontal", "vertical"])
|
||||
pressEnter: z
|
||||
.boolean()
|
||||
.optional()
|
||||
.describe(
|
||||
"Split direction: 'horizontal' (side by side) or 'vertical' (top/bottom). Default is 'vertical'"
|
||||
"Press Enter after typing the text (default: false). Set to true to execute shell commands or submit text input."
|
||||
),
|
||||
size: z
|
||||
.number()
|
||||
.min(1)
|
||||
.max(99)
|
||||
return_output: z
|
||||
.object({
|
||||
lines: z
|
||||
.number()
|
||||
.optional()
|
||||
.describe("Number of lines to capture (default: 200)"),
|
||||
wait: z
|
||||
.number()
|
||||
.optional()
|
||||
.describe("Milliseconds to wait before capturing output"),
|
||||
})
|
||||
.optional()
|
||||
.describe("Size of the new pane as percentage (1-99). Default is 50%"),
|
||||
.describe(
|
||||
"Capture terminal output after sending text. Specify 'wait' for slow commands."
|
||||
),
|
||||
},
|
||||
async ({ paneId, direction, size }) => {
|
||||
async ({ terminalId, text, pressEnter, return_output }) => {
|
||||
try {
|
||||
const newPane = await tmux.splitPane(
|
||||
paneId,
|
||||
direction || "vertical",
|
||||
size
|
||||
);
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: newPane
|
||||
? `Pane split successfully. New pane: ${JSON.stringify(
|
||||
newPane,
|
||||
null,
|
||||
2
|
||||
)}`
|
||||
: `Failed to split pane ${paneId}`,
|
||||
},
|
||||
],
|
||||
};
|
||||
} catch (error) {
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: `Error splitting pane: ${error}`,
|
||||
},
|
||||
],
|
||||
isError: true,
|
||||
};
|
||||
}
|
||||
}
|
||||
);
|
||||
// Get the pane for this terminal
|
||||
const panes = await tmux.listPanes(terminalId);
|
||||
const pane = panes[0];
|
||||
|
||||
// Execute shell command - Tool
|
||||
server.tool(
|
||||
"execute-shell-command",
|
||||
"Execute a shell command in a pane synchronously and return results immediately. Waits for command completion (default 30s timeout). Returns output, exit code, and status. Use for quick commands (ls, grep, npm test, etc.). Avoid heredoc syntax (cat << EOF) and multi-line constructs. IMPORTANT: For long-running commands (npm start, servers, watch processes), use send-text with pressEnter=true instead, then monitor output with capture-pane. For interactive apps or special keys, use send-keys.",
|
||||
{
|
||||
paneId: z.string().describe("ID of the pane"),
|
||||
command: z.string().describe("Shell command to execute"),
|
||||
timeout: z
|
||||
.number()
|
||||
.optional()
|
||||
.describe("Timeout in milliseconds (default: 30000)"),
|
||||
},
|
||||
async ({ paneId, command, timeout }) => {
|
||||
try {
|
||||
const result = await tmux.executeShellCommand({
|
||||
paneId,
|
||||
command,
|
||||
timeout,
|
||||
if (!pane) {
|
||||
throw new Error(`No pane found for terminal ${terminalId}`);
|
||||
}
|
||||
|
||||
const output = await tmux.sendText({
|
||||
paneId: pane.id,
|
||||
text,
|
||||
pressEnter,
|
||||
return_output,
|
||||
});
|
||||
|
||||
let statusText =
|
||||
result.status === "completed" ? "✅ Completed" : "❌ Error";
|
||||
if (return_output && output) {
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: `Text sent to terminal ${terminalId}${
|
||||
pressEnter ? " (with Enter)" : ""
|
||||
}.\n\n--- Output ---\n${output}`,
|
||||
},
|
||||
],
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: `${statusText}\nCommand: ${result.command}\nExit code: ${
|
||||
result.exitCode
|
||||
}\n\n--- Output ---\n${result.output || "(no output)"}`,
|
||||
text: `Text sent to terminal ${terminalId}${
|
||||
pressEnter ? " (with Enter)" : ""
|
||||
}.\n\nUse capture-terminal to verify the result.`,
|
||||
},
|
||||
],
|
||||
};
|
||||
@@ -400,7 +346,7 @@ server.tool(
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: `Error executing command: ${error}`,
|
||||
text: `Error sending text: ${error}`,
|
||||
},
|
||||
],
|
||||
isError: true,
|
||||
@@ -412,9 +358,9 @@ server.tool(
|
||||
// Send keys - Tool
|
||||
server.tool(
|
||||
"send-keys",
|
||||
"Send special keys or key combinations to a pane. Use for TUI navigation and control sequences. Examples: 'Up', 'Down', 'Enter', 'Escape', 'C-c' (Ctrl+C), 'M-x' (Alt+X). For typing regular text, use send-text instead. Supports repeating key presses and optionally capturing output after sending keys.",
|
||||
"Send special keys or key combinations to a terminal. Use for TUI navigation and control sequences. Examples: 'Up', 'Down', 'Enter', 'Escape', 'C-c' (Ctrl+C), 'M-x' (Alt+X). For typing regular text, use send-text instead. Supports repeating key presses and optionally capturing output after sending keys.",
|
||||
{
|
||||
paneId: z.string().describe("ID of the pane"),
|
||||
terminalId: z.string().describe("ID of the terminal (e.g., '@123')"),
|
||||
keys: z
|
||||
.string()
|
||||
.describe(
|
||||
@@ -438,13 +384,21 @@ server.tool(
|
||||
})
|
||||
.optional()
|
||||
.describe(
|
||||
"Capture pane output after sending keys. Specify 'wait' for slow commands."
|
||||
"Capture terminal output after sending keys. Specify 'wait' for slow commands."
|
||||
),
|
||||
},
|
||||
async ({ paneId, keys, repeat, return_output }) => {
|
||||
async ({ terminalId, keys, repeat, return_output }) => {
|
||||
try {
|
||||
// Get the pane for this terminal
|
||||
const panes = await tmux.listPanes(terminalId);
|
||||
const pane = panes[0];
|
||||
|
||||
if (!pane) {
|
||||
throw new Error(`No pane found for terminal ${terminalId}`);
|
||||
}
|
||||
|
||||
const output = await tmux.sendKeys({
|
||||
paneId,
|
||||
paneId: pane.id,
|
||||
keys,
|
||||
repeat,
|
||||
return_output,
|
||||
@@ -455,7 +409,7 @@ server.tool(
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: `Keys '${keys}' sent to pane ${paneId}${
|
||||
text: `Keys '${keys}' sent to terminal ${terminalId}${
|
||||
repeat && repeat > 1 ? ` (repeated ${repeat} times)` : ""
|
||||
}.\n\n--- Output ---\n${output}`,
|
||||
},
|
||||
@@ -467,9 +421,9 @@ server.tool(
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: `Keys '${keys}' sent to pane ${paneId}${
|
||||
text: `Keys '${keys}' sent to terminal ${terminalId}${
|
||||
repeat && repeat > 1 ? ` (repeated ${repeat} times)` : ""
|
||||
}.\n\nUse capture-pane to verify the result.`,
|
||||
}.\n\nUse capture-terminal to verify the result.`,
|
||||
},
|
||||
],
|
||||
};
|
||||
@@ -487,68 +441,22 @@ server.tool(
|
||||
}
|
||||
);
|
||||
|
||||
// Send text - Tool
|
||||
// Rename terminal - Tool
|
||||
server.tool(
|
||||
"send-text",
|
||||
"Type text into a pane. This is the PRIMARY way to execute shell commands with bash operators (&&, ||, |, ;, etc.) - set pressEnter=true to run the command. Also use for interactive applications, REPLs, forms, and text entry. For special keys or control sequences, use send-keys instead.",
|
||||
"rename-terminal",
|
||||
"Rename a terminal to a more descriptive name",
|
||||
{
|
||||
paneId: z.string().describe("ID of the pane"),
|
||||
text: z
|
||||
.string()
|
||||
.describe(
|
||||
"Text to type into the pane. For shell commands, can use any bash operators: && (chain), || (or), | (pipe), ; (sequential), etc."
|
||||
),
|
||||
pressEnter: z
|
||||
.boolean()
|
||||
.optional()
|
||||
.describe(
|
||||
"Press Enter after typing the text (default: false). Set to true to execute shell commands or submit text input."
|
||||
),
|
||||
return_output: z
|
||||
.object({
|
||||
lines: z
|
||||
.number()
|
||||
.optional()
|
||||
.describe("Number of lines to capture (default: 200)"),
|
||||
wait: z
|
||||
.number()
|
||||
.optional()
|
||||
.describe("Milliseconds to wait before capturing output"),
|
||||
})
|
||||
.optional()
|
||||
.describe(
|
||||
"Capture pane output after sending text. Specify 'wait' for slow commands."
|
||||
),
|
||||
terminalId: z.string().describe("ID of the terminal (e.g., '@123')"),
|
||||
name: z.string().describe("New name for the terminal"),
|
||||
},
|
||||
async ({ paneId, text, pressEnter, return_output }) => {
|
||||
async ({ terminalId, name }) => {
|
||||
try {
|
||||
const output = await tmux.sendText({
|
||||
paneId,
|
||||
text,
|
||||
pressEnter,
|
||||
return_output,
|
||||
});
|
||||
|
||||
if (return_output && output) {
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: `Text sent to pane ${paneId}${
|
||||
pressEnter ? " (with Enter)" : ""
|
||||
}.\n\n--- Output ---\n${output}`,
|
||||
},
|
||||
],
|
||||
};
|
||||
}
|
||||
|
||||
await tmux.renameWindow(terminalId, name);
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: `Text sent to pane ${paneId}${
|
||||
pressEnter ? " (with Enter)" : ""
|
||||
}.\n\nUse capture-pane to verify the result.`,
|
||||
text: `Terminal ${terminalId} renamed to "${name}"`,
|
||||
},
|
||||
],
|
||||
};
|
||||
@@ -557,7 +465,7 @@ server.tool(
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: `Error sending text: ${error}`,
|
||||
text: `Error renaming terminal: ${error}`,
|
||||
},
|
||||
],
|
||||
isError: true,
|
||||
@@ -566,24 +474,72 @@ server.tool(
|
||||
}
|
||||
);
|
||||
|
||||
// Expose session list as a resource
|
||||
server.resource("Sessions", "tmux://sessions", async () => {
|
||||
// Kill terminal - Tool
|
||||
server.tool(
|
||||
"kill-terminal",
|
||||
"Close a terminal and end its shell session",
|
||||
{
|
||||
terminalId: z.string().describe("ID of the terminal (e.g., '@123')"),
|
||||
},
|
||||
async ({ terminalId }) => {
|
||||
try {
|
||||
await tmux.killWindow(terminalId);
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: `Terminal ${terminalId} has been closed`,
|
||||
},
|
||||
],
|
||||
};
|
||||
} catch (error) {
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: `Error killing terminal: ${error}`,
|
||||
},
|
||||
],
|
||||
isError: true,
|
||||
};
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
// Expose terminals as a resource
|
||||
server.resource("Terminals", "tmux://terminals", async () => {
|
||||
try {
|
||||
const sessions = await tmux.listSessions();
|
||||
await ensureDefaultSession();
|
||||
|
||||
const session = await tmux.findSessionByName(DEFAULT_SESSION);
|
||||
if (!session) {
|
||||
throw new Error(`Default session not found: ${DEFAULT_SESSION}`);
|
||||
}
|
||||
|
||||
const windows = await tmux.listWindows(session.id);
|
||||
|
||||
const terminals = await Promise.all(
|
||||
windows.map(async (window) => {
|
||||
const panes = await tmux.listPanes(window.id);
|
||||
const pane = panes[0];
|
||||
const workingDirectory = pane
|
||||
? await tmux.getCurrentWorkingDirectory(pane.id)
|
||||
: "unknown";
|
||||
|
||||
return {
|
||||
id: window.id,
|
||||
name: window.name,
|
||||
active: window.active,
|
||||
workingDirectory,
|
||||
};
|
||||
})
|
||||
);
|
||||
|
||||
return {
|
||||
contents: [
|
||||
{
|
||||
uri: "tmux://sessions",
|
||||
text: JSON.stringify(
|
||||
sessions.map((session) => ({
|
||||
id: session.id,
|
||||
name: session.name,
|
||||
attached: session.attached,
|
||||
windows: session.windows,
|
||||
})),
|
||||
null,
|
||||
2
|
||||
),
|
||||
uri: "tmux://terminals",
|
||||
text: JSON.stringify(terminals, null, 2),
|
||||
},
|
||||
],
|
||||
};
|
||||
@@ -591,64 +547,65 @@ server.resource("Sessions", "tmux://sessions", async () => {
|
||||
return {
|
||||
contents: [
|
||||
{
|
||||
uri: "tmux://sessions",
|
||||
text: `Error listing sessions: ${error}`,
|
||||
uri: "tmux://terminals",
|
||||
text: `Error listing terminals: ${error}`,
|
||||
},
|
||||
],
|
||||
};
|
||||
}
|
||||
});
|
||||
|
||||
// Expose pane content as a resource
|
||||
// Expose terminal content as a resource
|
||||
server.resource(
|
||||
"Pane Content",
|
||||
new ResourceTemplate("tmux://pane/{paneId}", {
|
||||
"Terminal Content",
|
||||
new ResourceTemplate("tmux://terminal/{terminalId}", {
|
||||
list: async () => {
|
||||
try {
|
||||
// Get all sessions
|
||||
const sessions = await tmux.listSessions();
|
||||
const paneResources = [];
|
||||
await ensureDefaultSession();
|
||||
|
||||
// For each session, get all windows
|
||||
for (const session of sessions) {
|
||||
const windows = await tmux.listWindows(session.id);
|
||||
|
||||
// For each window, get all panes
|
||||
for (const window of windows) {
|
||||
const panes = await tmux.listPanes(window.id);
|
||||
|
||||
// For each pane, create a resource with descriptive name
|
||||
for (const pane of panes) {
|
||||
paneResources.push({
|
||||
name: `Pane: ${session.name} - ${pane.id} - ${pane.title} ${
|
||||
pane.active ? "(active)" : ""
|
||||
}`,
|
||||
uri: `tmux://pane/${pane.id}`,
|
||||
description: `Content from pane ${pane.id} - ${pane.title} in session ${session.name}`,
|
||||
});
|
||||
}
|
||||
}
|
||||
const session = await tmux.findSessionByName(DEFAULT_SESSION);
|
||||
if (!session) {
|
||||
return { resources: [] };
|
||||
}
|
||||
|
||||
const windows = await tmux.listWindows(session.id);
|
||||
|
||||
const terminalResources = windows.map((window) => ({
|
||||
name: `Terminal: ${window.name} ${window.active ? "(active)" : ""}`,
|
||||
uri: `tmux://terminal/${window.id}`,
|
||||
description: `Content from terminal ${window.name}`,
|
||||
}));
|
||||
|
||||
return {
|
||||
resources: paneResources,
|
||||
resources: terminalResources,
|
||||
};
|
||||
} catch (error) {
|
||||
server.server.sendLoggingMessage({
|
||||
level: "error",
|
||||
data: `Error listing panes: ${error}`,
|
||||
data: `Error listing terminals: ${error}`,
|
||||
});
|
||||
|
||||
return { resources: [] };
|
||||
}
|
||||
},
|
||||
}),
|
||||
async (uri, { paneId }) => {
|
||||
async (uri, { terminalId }) => {
|
||||
try {
|
||||
// Ensure paneId is a string
|
||||
const paneIdStr = Array.isArray(paneId) ? paneId[0] : paneId;
|
||||
// Default to no colors for resources to maintain clean programmatic access
|
||||
const content = await tmux.capturePaneContent(paneIdStr, 200, false);
|
||||
// Ensure terminalId is a string
|
||||
const terminalIdStr = Array.isArray(terminalId)
|
||||
? terminalId[0]
|
||||
: terminalId;
|
||||
|
||||
// Get the pane for this terminal
|
||||
const panes = await tmux.listPanes(terminalIdStr);
|
||||
const pane = panes[0];
|
||||
|
||||
if (!pane) {
|
||||
throw new Error(`No pane found for terminal ${terminalIdStr}`);
|
||||
}
|
||||
|
||||
const content = await tmux.capturePaneContent(pane.id, 200, false);
|
||||
|
||||
return {
|
||||
contents: [
|
||||
{
|
||||
@@ -662,7 +619,7 @@ server.resource(
|
||||
contents: [
|
||||
{
|
||||
uri: uri.href,
|
||||
text: `Error capturing pane content: ${error}`,
|
||||
text: `Error capturing terminal content: ${error}`,
|
||||
},
|
||||
],
|
||||
};
|
||||
@@ -687,6 +644,9 @@ async function main() {
|
||||
type: values["shell-type"] as string,
|
||||
});
|
||||
|
||||
// Ensure default session exists
|
||||
await ensureDefaultSession();
|
||||
|
||||
console.log(values, process.argv);
|
||||
|
||||
// Check if HTTP mode is enabled
|
||||
|
||||
@@ -169,6 +169,15 @@ export async function capturePaneContent(
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the current working directory of a pane
|
||||
*/
|
||||
export async function getCurrentWorkingDirectory(
|
||||
paneId: string
|
||||
): Promise<string> {
|
||||
return executeTmux(`display-message -p -t '${paneId}' '#{pane_current_path}'`);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a new tmux session
|
||||
*/
|
||||
|
||||
Reference in New Issue
Block a user