@adiontaegerron/claude-multi-terminal 1.2.0 → 2.1.0

package/.claude/settings.local.json

@@ -1,23 +1,16 @@
 {
   "permissions": {
     "allow": [
-      "Bash(find:*)",
-      "Bash(npm init:*)",
-      "Bash(npm install:*)",
-      "Bash(npm start)",
-      "Bash(npx:*)",
+      "Bash(create_terminal \"Terminal 3\")",
+      "Bash(terminal_help)",
+      "Bash(create_terminal \"Terminal 4\")",
       "Bash(rm:*)",
-      "Bash(npm run rebuild:*)",
-      "Bash(git init:*)",
-      "Bash(git remote add:*)",
-      "Bash(git add:*)",
-      "Bash(git commit:*)",
-      "Bash(git push:*)",
-      "Bash(mkdir:*)",
+      "Bash(create_terminal \"Terminal 2\")",
       "Bash(chmod:*)",
-      "Bash(npm:*)",
-      "Bash(claude --print \"Please enter plan mode (press Shift+Tab twice)\")",
-      "WebFetch(domain:docs.anthropic.com)"
+      "Bash(*)",
+      "Bash(/tmp/create_terminals.sh:*)",
+      "Bash(ls:*)",
+      "Write(*)"
     ],
     "deny": []
   }

package/CLAUDE.md

@@ -1,63 +1,96 @@
-# CLAUDE.md
+# Terminal Agent Instructions
 
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+You are a terminal agent running in a multi-terminal coordination system. Your terminal name will be provided when you start.
 
-## Project Overview
+## IMPORTANT: Follow Instructions Exactly
 
-This is a multi-terminal desktop application built with Electron, xterm.js, and node-pty. It allows users to manage multiple terminal sessions with individual UI controls for each terminal.
+When given a command:
+- Execute ONLY what is explicitly requested
+- Do NOT add extra actions or create additional items
+- If asked to create 2 terminals, create exactly 2 (not 3, 4, or 6)
+- Wait for further instructions after completing each task
 
-## Development Commands
+## Communication Commands
 
-Since this is a new project, standard Electron/Node.js commands will be used:
+You communicate with other terminals using file-based IPC. Use the Write tool to create command files in `.ipc-messages/`.
 
-```bash
-# Install dependencies
-npm install
+### Command Format
 
-# Start the application in development mode
-npm start
+Use the Write tool to create files with unique names. Include your name in the filename to ensure uniqueness:
+`.ipc-messages/cmd_YourName_timestamp.txt`
 
-# Build the application (once configured)
-npm run build
+Always use the exact terminal name you were given at startup.
 
-# Run tests (once configured)
-npm test
+### Send Message to Another Terminal
+Use Write to create a file `.ipc-messages/msg_YourName_[timestamp].txt` with content:
+```
+YourName:IPC:SEND:TargetTerminal:Your message
 ```
 
-## Architecture
+### Broadcast to All Terminals
+Use Write to create a file `.ipc-messages/bcast_YourName_[timestamp].txt` with content:
+```
+YourName:IPC:BROADCAST:Your message
+```
 
-The application follows a standard Electron architecture:
+### List All Terminals
+Use Write to create a file `.ipc-messages/list_YourName_[timestamp].txt` with content:
+```
+YourName:IPC:LIST
+```
 
-- **Main Process**: Manages window creation, native OS interactions, and spawns terminal processes using node-pty
-- **Renderer Process**: Handles the UI, terminal rendering with xterm.js, and user interactions
-- **IPC Communication**: Main and renderer processes communicate via Electron's IPC for terminal operations
+### Create New Terminal
+Use Write to create a file `.ipc-messages/create_YourName_[timestamp].txt` with content:
+```
+YourName:IPC:CREATE:NewTerminalName
+```
+The name is optional - if not provided, a default name will be assigned.
 
-Key components:
-- Terminal instances are managed by node-pty in the main process
-- Each terminal UI is rendered by xterm.js in the renderer
-- Commands are sent from text inputs to terminals via IPC
+### Close Terminal
+Use Write to create a file `.ipc-messages/close_YourName_[timestamp].txt` with content:
+```
+YourName:IPC:CLOSE:TargetTerminal
+```
+Note: You cannot close your own terminal.
+
+### Rename Terminal
+Use Write to create a file `.ipc-messages/rename_YourName_[timestamp].txt` with content:
+```
+YourName:IPC:RENAME:TargetTerminal:NewName
+```
+
+### Get Terminal Status
+Use Write to create a file `.ipc-messages/status_YourName_[timestamp].txt` with content:
+```
+YourName:IPC:STATUS:TargetTerminal
+```
 
-## Project Requirements
+**Important**: Replace [timestamp] with a unique number or use the current timestamp when creating files.
 
-The application must support:
-- Multiple terminal sessions (2+ terminals)
-- Each terminal displays:
-  - xterm.js terminal area for output and keyboard input
-  - Text input box for sending commands
-  - Send button (Enter key also submits)
-- "New Terminal" button for creating sessions
-- Real-time output display
-- Local execution only (no cloud dependencies)
+## Important Rules
 
-Optional features:
-- Tabs or sidebar for terminal switching
-- Individual terminal close functionality
+1. Terminal names are case-sensitive
+2. You cannot send messages to yourself
+3. You cannot close your own terminal
+4. Maximum of 6 terminals can exist
+5. Messages are delivered instantly
+6. When you receive a message, it will appear as:
+   - `💬 Message from Terminal X: [message]`
+   - `📢 Broadcast from Terminal X: [message]`
 
-## Technical Stack
+## Your Role
 
-- **Electron**: Desktop application framework
-- **xterm.js**: Terminal UI rendering
-- **node-pty**: Terminal process management
-- **JavaScript/TypeScript**: Implementation language (choose based on simplicity)
+As a terminal agent, you should:
+- Wait for messages and commands from other terminals
+- When you receive a message ending with "[End of message - no response needed]", do NOT respond automatically
+- Only respond to messages when they contain a specific request or question
+- Execute tasks as directed
+- Communicate status updates when appropriate
+- Avoid taking actions unless specifically requested
 
+## Important: Message Handling
 
+When you receive messages from other terminals:
+- Messages marked with "[End of message - no response needed]" are notifications only
+- Do not echo or respond to these messages unless they contain a specific request
+- Wait for explicit instructions before taking action

package/README.md

@@ -1,5 +1,7 @@
 # Claude Multi-Terminal
 
+**Note for Terminal Agents**: If you are a Claude instance running inside this application, you don't need to read this file. Please refer to CLAUDE.md for your instructions.
+
 A multi-terminal editor for coordinating multiple Claude Code instances. Run multiple Claude sessions side-by-side with a unified chat interface to send commands to selected terminals.
 
 ![Claude Multi-Terminal Screenshot](screenshot.png)
@@ -7,20 +9,35 @@ A multi-terminal editor for coordinating multiple Claude Code instances. Run mul
 ## Features
 
 - **Multi-Terminal Support**: Run multiple Claude Code instances in a 2x2 grid layout
-- **Unified Chat Interface**: Send commands to selected terminals from a single chat interface
-- **Terminal Selection**: Choose which terminals receive your commands with checkboxes
-- **Multi-@ Terminal Commands**: Send commands to multiple terminals with various syntaxes:
+- **Unified Chat Interface**: Send commands to terminals using @ syntax
+- **Multi-@ Terminal Commands**: Target terminals with flexible syntax:
   - `@all command` - Send to all terminals
   - `@term1,term2,term3 command` - Comma-separated terminals
   - `@term1 @term2 command` - Space-separated terminals
-- **Smart Autocomplete**: Get terminal suggestions while typing @ anywhere in your message
-- **Slash Commands**: Built-in commands for terminal management
+- **Mixed @/ Commands**: Combine terminal targeting with slash commands:
+  - `@term1 /clear` - Run slash command on specific terminal
+  - `@term1 @term2 /list` - Multiple terminals with slash commands
+  - `@all /interrupt` - Slash commands with @all
+- **Smart Autocomplete**: Get suggestions while typing @ or / anywhere in your message
+- **Slash Commands**: Built-in commands for terminal management (works anywhere)
 - **Default Prompt**: Set a default prompt to prepend to all messages
 - **Plan Mode Support**: Automatically enters plan mode with Shift+Tab
 - **Auto-Start Claude**: Each terminal automatically starts Claude Code
+- **Inter-Claude Communication**: Claude instances can chat and coordinate using echo commands
+- **Terminal Management**: Claude can create, close, and rename terminals autonomously
 - **Rename Terminals**: Double-click terminal titles to rename them
 - **Responsive Layout**: Adapts to different screen sizes
 
+## Breaking Changes in v2.0
+
+- **Removed checkbox selection system** - All commands must now use @ syntax
+- **No default terminal selection** - You must explicitly specify terminals with @
+- **Plain text without @ or / will show an error** - Every command needs a target
+
+To migrate from v1.x:
+- Instead of selecting checkboxes and typing a command, use: `@term1 @term2 command`
+- To send to all terminals, use: `@all command`
+
 ## Installation
 
 ### From npm
@@ -52,10 +69,12 @@ This will open the multi-terminal editor with all terminals starting in your cur
 
 1. **Start the Application**: Run `claude-multi` in your project directory
 2. **Create Terminals**: Click "New Terminal" to add more Claude instances (starts with one)
-3. **Select Terminals**: Use checkboxes in the chat sidebar to select which terminals receive commands
-4. **Send Commands**: Type in the chat input and click "Send" or press Enter
+3. **Target Terminals**: Use @ syntax to specify which terminals receive commands
+4. **Send Commands**: Type your command with @ targeting and press Enter
 5. **Use Default Prompt**: Expand the "Default Prompt" section to set a prompt that's prepended to all messages
 
+**Important**: Version 2.0 removes checkbox selection. All commands must now use @ syntax to target terminals.
+
 ### Slash Commands
 
 - `/send <terminal> <command>` - Send command to specific terminal
@@ -79,13 +98,29 @@ Send commands directly to terminals using @ syntax:
 
 **Autocomplete**: Type `@` anywhere to get terminal suggestions!
 
+### Claude-to-Claude Communication
+
+Claude instances communicate by creating files in the `.ipc-messages/` directory. Claude will handle the file creation directly when asked to:
+
+- **Send message**: Claude creates a file to send `TerminalName:IPC:SEND:Target:Message`
+- **Broadcast**: Claude creates a file to broadcast `TerminalName:IPC:BROADCAST:Message`
+- **Create terminal**: Claude creates a file with `TerminalName:IPC:CREATE:NewName`
+- **Close terminal**: Claude creates a file with `TerminalName:IPC:CLOSE:Target`
+- **Rename terminal**: Claude creates a file with `TerminalName:IPC:RENAME:Target:NewName`
+- **List terminals**: Claude creates a file with `TerminalName:IPC:LIST`
+- **Get status**: Claude creates a file with `TerminalName:IPC:STATUS:Target`
+
+Claude knows how to create these files when you ask it to communicate with other terminals. This enables Claude instances to work together as a coordinated team.
+
 ### Tips
 
 - Each terminal automatically starts Claude Code when created
+- Claude receives its identity: "You are a terminal agent. Your name is [Terminal Name]."
 - Plan mode is activated automatically using Shift+Tab
 - Double-click terminal titles to rename them for better organization
 - The application uses your current directory as the working directory for all terminals
 - Use multi-@ commands to coordinate multiple Claude instances efficiently
+- Claude instances communicate instantly using IPC echo commands for seamless teamwork
 
 ## Development
 

package/index.html

@@ -14,13 +14,6 @@
         
         <div id="toolbar-extended">
             <div class="controls-row">
-                <div id="terminal-selector" class="control-section">
-                    <label>Send to:</label>
-                    <div id="terminal-checkboxes">
-                        <!-- Terminal checkboxes will be added here dynamically -->
-                    </div>
-                </div>
-                
                 <div id="default-prompt-section" class="control-section collapsible">
                     <div class="collapsible-header">
                         <button class="collapse-toggle">▶</button>

package/ipc-handlers.js

@@ -0,0 +1,303 @@
+// IPC Handlers for Direct Terminal Communication
+// Handles IPC calls from injected JavaScript functions
+
+const { ipcMain } = require('electron');
+
+class DirectIPCHandler {
+  constructor() {
+    this.terminals = null; // Will be set by main process
+    this.mainWindow = null; // Will be set by main process
+    this.setupHandlers();
+  }
+
+  setTerminals(terminals) {
+    this.terminals = terminals;
+  }
+
+  setMainWindow(mainWindow) {
+    this.mainWindow = mainWindow;
+  }
+
+  setupHandlers() {
+    // Send message between terminals
+    ipcMain.handle('terminal:send-message', async (event, data) => {
+      try {
+        const { from, to, message, timestamp } = data;
+        
+        const targetTerminal = this.findTerminal(to);
+        if (!targetTerminal) {
+          return { success: false, error: `Terminal '${to}' not found` };
+        }
+
+        const chatMessage = `💬 Message from ${from}:\n${message}`;
+        this.mainWindow.webContents.send('terminal:system-response', targetTerminal.id, {
+          message: chatMessage,
+          type: 'chat',
+          timestamp: timestamp || Date.now()
+        });
+
+        // Send return to submit message
+        setTimeout(() => {
+          targetTerminal.pty.write('\r');
+        }, 200);
+
+        return { success: true, target: to, from };
+      } catch (error) {
+        return { success: false, error: error.message };
+      }
+    });
+
+    // Create new terminal
+    ipcMain.handle('terminal:create-new', async (event, data) => {
+      try {
+        const { name, requesterId } = data;
+        
+        // Check terminal limit
+        if (this.terminals.size >= 6) {
+          return { success: false, error: 'Maximum of 6 terminals allowed' };
+        }
+
+        // Rate limiting check
+        const requesterTerminal = this.terminals.get(requesterId);
+        if (requesterTerminal) {
+          const now = Date.now();
+          const timeSinceLastCreate = now - (requesterTerminal.lastCreateRequest || 0);
+          if (timeSinceLastCreate < 2000) {
+            return { 
+              success: false, 
+              error: `Please wait ${Math.ceil((2000 - timeSinceLastCreate) / 1000)} seconds before creating another terminal`
+            };
+          }
+          requesterTerminal.lastCreateRequest = now;
+        }
+
+        // Trigger terminal creation
+        this.mainWindow.webContents.send('terminal:create-request', name);
+        
+        return { 
+          success: true, 
+          terminalId: `terminal-${Date.now()}`, // Temporary ID
+          name: name 
+        };
+      } catch (error) {
+        return { success: false, error: error.message };
+      }
+    });
+
+    // Close terminal
+    ipcMain.handle('terminal:close-target', async (event, data) => {
+      try {
+        const { target, requesterId } = data;
+        
+        const targetTerminal = this.findTerminal(target);
+        if (!targetTerminal) {
+          return { success: false, error: `Terminal '${target}' not found` };
+        }
+
+        if (targetTerminal.id === requesterId) {
+          return { success: false, error: 'Cannot close your own terminal' };
+        }
+
+        targetTerminal.pty.kill();
+        this.terminals.delete(targetTerminal.id);
+        
+        this.mainWindow.webContents.send('terminal:closed', targetTerminal.id);
+        
+        return { success: true, target, closed: targetTerminal.name };
+      } catch (error) {
+        return { success: false, error: error.message };
+      }
+    });
+
+    // Rename terminal
+    ipcMain.handle('terminal:rename-target', async (event, data) => {
+      try {
+        const { target, newName, requesterId } = data;
+        
+        const targetTerminal = this.findTerminal(target);
+        if (!targetTerminal) {
+          return { success: false, error: `Terminal '${target}' not found` };
+        }
+
+        const oldName = targetTerminal.name;
+        targetTerminal.name = newName;
+        
+        this.mainWindow.webContents.send('terminal:renamed', targetTerminal.id, newName);
+        
+        return { success: true, target, oldName, newName };
+      } catch (error) {
+        return { success: false, error: error.message };
+      }
+    });
+
+    // List all terminals
+    ipcMain.handle('terminal:list-all', async (event) => {
+      try {
+        const terminalList = Array.from(this.terminals.entries()).map(([id, terminal]) => ({
+          id,
+          name: terminal.name,
+          status: terminal.status || 'active',
+          hasClaudeStarted: terminal.hasClaudeStarted || false
+        }));
+        
+        return { success: true, terminals: terminalList };
+      } catch (error) {
+        return { success: false, error: error.message };
+      }
+    });
+
+    // Get terminal status
+    ipcMain.handle('terminal:get-status', async (event, data) => {
+      try {
+        const { target } = data;
+        
+        const targetTerminal = this.findTerminal(target);
+        if (!targetTerminal) {
+          return { success: false, error: `Terminal '${target}' not found` };
+        }
+
+        const status = {
+          id: targetTerminal.id,
+          name: targetTerminal.name,
+          status: targetTerminal.status || 'active',
+          hasClaudeStarted: targetTerminal.hasClaudeStarted || false
+        };
+
+        return { success: true, target, status };
+      } catch (error) {
+        return { success: false, error: error.message };
+      }
+    });
+
+    // Broadcast message to all terminals
+    ipcMain.handle('terminal:broadcast', async (event, data) => {
+      try {
+        const { message, from, excludeId } = data;
+        
+        let count = 0;
+        for (const [id, terminal] of this.terminals.entries()) {
+          if (excludeId && id === excludeId) continue; // Don't send to sender
+          
+          const chatMessage = `📢 Broadcast from ${from}:\n${message}`;
+          this.mainWindow.webContents.send('terminal:system-response', id, {
+            message: chatMessage,
+            type: 'chat',
+            timestamp: Date.now()
+          });
+          
+          count++;
+        }
+
+        return { success: true, count, message };
+      } catch (error) {
+        return { success: false, error: error.message };
+      }
+    });
+
+    // Advanced workflow handlers
+    ipcMain.handle('terminal:workflow-setup', async (event, data) => {
+      try {
+        const { type, requesterId } = data;
+        
+        const workflows = {
+          'development': [
+            'Backend Server',
+            'Frontend Dev',
+            'Database',
+            'Test Runner'
+          ],
+          'review': [
+            'Code Reviewer',
+            'Test Runner', 
+            'Build Monitor'
+          ],
+          'debug': [
+            'Bug Hunter',
+            'Log Monitor',
+            'Test Verifier'
+          ]
+        };
+
+        const terminalNames = workflows[type];
+        if (!terminalNames) {
+          return { success: false, error: `Unknown workflow type: ${type}` };
+        }
+
+        // Check if we can create all terminals
+        if (this.terminals.size + terminalNames.length > 6) {
+          return { 
+            success: false, 
+            error: `Cannot create ${terminalNames.length} terminals. Would exceed limit of 6.` 
+          };
+        }
+
+        // Create terminals
+        const created = [];
+        for (const name of terminalNames) {
+          this.mainWindow.webContents.send('terminal:create-request', name);
+          created.push(name);
+          // Small delay between creations
+          await new Promise(resolve => setTimeout(resolve, 500));
+        }
+
+        return { success: true, type, created };
+      } catch (error) {
+        return { success: false, error: error.message };
+      }
+    });
+
+    // Health check
+    ipcMain.handle('terminal:health', async (event) => {
+      try {
+        return {
+          success: true,
+          terminalCount: this.terminals.size,
+          uptime: process.uptime(),
+          platform: process.platform,
+          memory: process.memoryUsage()
+        };
+      } catch (error) {
+        return { success: false, error: error.message };
+      }
+    });
+  }
+
+  // Helper method to find terminals
+  findTerminal(identifier) {
+    if (!this.terminals) {
+      throw new Error('Terminals not initialized');
+    }
+
+    // Try by ID first
+    if (this.terminals.has(identifier)) {
+      return this.terminals.get(identifier);
+    }
+    
+    // Try by name (exact match)
+    for (const [id, terminal] of this.terminals.entries()) {
+      if (terminal.name === identifier) {
+        return terminal;
+      }
+    }
+    
+    // Try by name (partial match)
+    for (const [id, terminal] of this.terminals.entries()) {
+      if (terminal.name.toLowerCase().includes(identifier.toLowerCase())) {
+        return terminal;
+      }
+    }
+    
+    // Try by position
+    const position = parseInt(identifier);
+    if (!isNaN(position) && position > 0) {
+      const terminalArray = Array.from(this.terminals.values());
+      if (position <= terminalArray.length) {
+        return terminalArray[position - 1];
+      }
+    }
+    
+    return null;
+  }
+}
+
+module.exports = DirectIPCHandler;