claude_swarm 0.1.11 → 0.1.13

data/lib/claude_swarm/cli.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "thor"
+require "json"
 require_relative "configuration"
 require_relative "mcp_generator"
 require_relative "orchestrator"
@@ -24,7 +25,15 @@ module ClaudeSwarm
                                 desc: "Stream session logs to stdout (only works with -p)"
     method_option :debug, type: :boolean, default: false,
                           desc: "Enable debug output"
+    method_option :session_id, type: :string,
+                               desc: "Resume a previous session by ID or path"
     def start(config_file = nil)
+      # Handle session restoration
+      if options[:session_id]
+        restore_session(options[:session_id])
+        return
+      end
+
       config_path = config_file || options[:config]
       unless File.exist?(config_path)
         error "Configuration file not found: #{config_path}"
@@ -41,12 +50,10 @@ module ClaudeSwarm
 
       begin
         config = Configuration.new(config_path)
-        session_timestamp = Time.now.strftime("%Y%m%d_%H%M%S")
-        generator = McpGenerator.new(config, vibe: options[:vibe], timestamp: session_timestamp)
+        generator = McpGenerator.new(config, vibe: options[:vibe])
         orchestrator = Orchestrator.new(config, generator,
                                         vibe: options[:vibe],
                                         prompt: options[:prompt],
-                                        session_timestamp: session_timestamp,
                                         stream_logs: options[:stream_logs],
                                         debug: options[:debug])
         orchestrator.start
@@ -83,6 +90,12 @@ module ClaudeSwarm
                          desc: "Run with --dangerously-skip-permissions"
     method_option :calling_instance, type: :string, required: true,
                                      desc: "Name of the instance that launched this MCP server"
+    method_option :calling_instance_id, type: :string,
+                                        desc: "Unique ID of the instance that launched this MCP server"
+    method_option :instance_id, type: :string,
+                                desc: "Unique ID of this instance"
+    method_option :claude_session_id, type: :string,
+                                      desc: "Claude session ID to resume"
     def mcp_serve
       instance_config = {
         name: options[:name],
@@ -93,11 +106,17 @@ module ClaudeSwarm
         tools: options[:tools] || [],
         disallowed_tools: options[:disallowed_tools] || [],
         mcp_config_path: options[:mcp_config_path],
-        vibe: options[:vibe]
+        vibe: options[:vibe],
+        instance_id: options[:instance_id],
+        claude_session_id: options[:claude_session_id]
       }
 
       begin
-        server = ClaudeMcpServer.new(instance_config, calling_instance: options[:calling_instance])
+        server = ClaudeMcpServer.new(
+          instance_config,
+          calling_instance: options[:calling_instance],
+          calling_instance_id: options[:calling_instance_id]
+        )
         server.start
       rescue StandardError => e
         error "Error starting MCP server: #{e.message}"
@@ -173,6 +192,79 @@ module ClaudeSwarm
       say "Claude Swarm #{VERSION}"
     end
 
+    desc "list-sessions", "List all available Claude Swarm sessions"
+    method_option :limit, aliases: "-l", type: :numeric, default: 10,
+                          desc: "Maximum number of sessions to display"
+    def list_sessions
+      sessions_dir = File.expand_path("~/.claude-swarm/sessions")
+      unless Dir.exist?(sessions_dir)
+        say "No sessions found", :yellow
+        return
+      end
+
+      # Find all sessions with MCP configs
+      sessions = []
+      Dir.glob("#{sessions_dir}/*/*/*.mcp.json").each do |mcp_path|
+        session_path = File.dirname(mcp_path)
+        session_id = File.basename(session_path)
+        project_name = File.basename(File.dirname(session_path))
+
+        # Skip if we've already processed this session
+        next if sessions.any? { |s| s[:path] == session_path }
+
+        # Try to load session info
+        config_file = File.join(session_path, "config.yml")
+        next unless File.exist?(config_file)
+
+        # Load the config to get swarm info
+        config_data = YAML.load_file(config_file)
+        swarm_name = config_data.dig("swarm", "name") || "Unknown"
+        main_instance = config_data.dig("swarm", "main") || "Unknown"
+
+        mcp_files = Dir.glob(File.join(session_path, "*.mcp.json"))
+
+        # Get creation time from directory
+        created_at = File.stat(session_path).ctime
+
+        sessions << {
+          path: session_path,
+          id: session_id,
+          project: project_name,
+          created_at: created_at,
+          main_instance: main_instance,
+          instances_count: mcp_files.size,
+          swarm_name: swarm_name,
+          config_path: config_file
+        }
+      rescue StandardError
+        # Skip invalid manifests
+        next
+      end
+
+      if sessions.empty?
+        say "No sessions found", :yellow
+        return
+      end
+
+      # Sort by creation time (newest first)
+      sessions.sort_by! { |s| -s[:created_at].to_i }
+      sessions = sessions.first(options[:limit])
+
+      # Display sessions
+      say "\nAvailable sessions (newest first):\n", :bold
+      sessions.each do |session|
+        say "\n#{session[:project]}/#{session[:id]}", :green
+        say "  Created: #{session[:created_at].strftime("%Y-%m-%d %H:%M:%S")}"
+        say "  Main: #{session[:main_instance]}"
+        say "  Instances: #{session[:instances_count]}"
+        say "  Swarm: #{session[:swarm_name]}"
+        say "  Config: #{session[:config_path]}", :cyan
+      end
+
+      say "\nTo resume a session, run:", :bold
+      say "  claude-swarm --session-id <session-id>", :cyan
+    end
+
     desc "tools-mcp", "Start a permission management MCP server for tool access control"
     method_option :allowed_tools, aliases: "-t", type: :string,
                                   desc: "Comma-separated list of allowed tool patterns (supports wildcards)"
@@ -196,5 +288,77 @@ module ClaudeSwarm
     def error(message)
       say message, :red
     end
+
+    def restore_session(session_id)
+      say "Restoring session: #{session_id}", :green
+
+      # Find the session path
+      session_path = find_session_path(session_id)
+      unless session_path
+        error "Session not found: #{session_id}"
+        exit 1
+      end
+
+      begin
+        # Load session info from instance ID in MCP config
+        mcp_files = Dir.glob(File.join(session_path, "*.mcp.json"))
+        if mcp_files.empty?
+          error "No MCP configuration files found in session"
+          exit 1
+        end
+
+        # Load the configuration from the session directory
+        config_file = File.join(session_path, "config.yml")
+
+        unless File.exist?(config_file)
+          error "Configuration file not found in session"
+          exit 1
+        end
+
+        # Change to the original start directory if it exists
+        start_dir_file = File.join(session_path, "start_directory")
+        if File.exist?(start_dir_file)
+          original_dir = File.read(start_dir_file).strip
+          if Dir.exist?(original_dir)
+            Dir.chdir(original_dir)
+            say "Changed to original directory: #{original_dir}", :green unless options[:prompt]
+          else
+            error "Original directory no longer exists: #{original_dir}"
+            exit 1
+          end
+        end
+
+        config = Configuration.new(config_file, base_dir: Dir.pwd)
+
+        # Create orchestrator with restoration mode
+        generator = McpGenerator.new(config, vibe: options[:vibe], restore_session_path: session_path)
+        orchestrator = Orchestrator.new(config, generator,
+                                        vibe: options[:vibe],
+                                        prompt: options[:prompt],
+                                        stream_logs: options[:stream_logs],
+                                        debug: options[:debug],
+                                        restore_session_path: session_path)
+        orchestrator.start
+      rescue StandardError => e
+        error "Failed to restore session: #{e.message}"
+        error e.backtrace.join("\n") if options[:debug]
+        exit 1
+      end
+    end
+
+    def find_session_path(session_id)
+      sessions_dir = File.expand_path("~/.claude-swarm/sessions")
+
+      # Check if it's a full path
+      return session_id if File.exist?(File.join(session_id, "config.yml"))
+
+      # Search for the session ID in all projects
+      Dir.glob("#{sessions_dir}/*/#{session_id}").each do |path|
+        config_path = File.join(path, "config.yml")
+        return path if File.exist?(config_path)
+      end
+
+      nil
+    end
   end
 end

data/lib/claude_swarm/configuration.rb

@@ -5,11 +5,11 @@ require "pathname"
 
 module ClaudeSwarm
   class Configuration
-    attr_reader :config, :swarm_name, :main_instance, :instances
+    attr_reader :config, :config_path, :swarm, :swarm_name, :main_instance, :instances
 
-    def initialize(config_path)
+    def initialize(config_path, base_dir: nil)
       @config_path = Pathname.new(config_path).expand_path
-      @config_dir = @config_path.dirname
+      @config_dir = base_dir || @config_path.dirname
       load_and_validate
     end
 
@@ -60,14 +60,15 @@ module ClaudeSwarm
     end
 
     def parse_swarm
-      swarm = @config["swarm"]
-      @swarm_name = swarm["name"]
-      @main_instance = swarm["main"]
+      @swarm = @config["swarm"]
+      @swarm_name = @swarm["name"]
+      @main_instance = @swarm["main"]
       @instances = {}
-      swarm["instances"].each do |name, config|
+      @swarm["instances"].each do |name, config|
         @instances[name] = parse_instance(name, config)
       end
       validate_connections
+      detect_circular_dependencies
     end
 
     def parse_instance(name, config)
@@ -127,6 +128,31 @@ module ClaudeSwarm
       end
     end
 
+    def detect_circular_dependencies
+      @instances.each_key do |instance_name|
+        visited = Set.new
+        path = []
+        detect_cycle_from(instance_name, visited, path)
+      end
+    end
+
+    def detect_cycle_from(instance_name, visited, path)
+      return if visited.include?(instance_name)
+
+      if path.include?(instance_name)
+        cycle_start = path.index(instance_name)
+        cycle = path[cycle_start..] + [instance_name]
+        raise Error, "Circular dependency detected: #{cycle.join(" -> ")}"
+      end
+
+      path.push(instance_name)
+      @instances[instance_name][:connections].each do |connection|
+        detect_cycle_from(connection, visited, path)
+      end
+      path.pop
+      visited.add(instance_name)
+    end
+
     def validate_directories
       @instances.each do |name, instance|
         directory = instance[:directory]

data/lib/claude_swarm/mcp_generator.rb

@@ -3,45 +3,52 @@
 require "json"
 require "fileutils"
 require "shellwords"
+require "securerandom"
+require_relative "session_path"
 
 module ClaudeSwarm
   class McpGenerator
-    SWARM_DIR = ".claude-swarm"
-    SESSIONS_SUBDIR = "sessions"
-
-    def initialize(configuration, vibe: false, timestamp: nil)
+    def initialize(configuration, vibe: false, restore_session_path: nil)
       @config = configuration
       @vibe = vibe
-      @timestamp = timestamp || Time.now.strftime("%Y%m%d_%H%M%S")
+      @restore_session_path = restore_session_path
+      @session_path = nil # Will be set when needed
+      @instance_ids = {} # Store instance IDs for all instances
+      @restore_states = {} # Store loaded state data during restoration
     end
 
     def generate_all
       ensure_swarm_directory
 
+      if @restore_session_path
+        # Load existing instance IDs and states from state files
+        load_instance_states
+      else
+        # Generate new instance IDs
+        @config.instances.each_key do |name|
+          @instance_ids[name] = "#{name}_#{SecureRandom.hex(4)}"
+        end
+      end
+
       @config.instances.each do |name, instance|
         generate_mcp_config(name, instance)
       end
     end
 
     def mcp_config_path(instance_name)
-      File.join(Dir.pwd, SWARM_DIR, SESSIONS_SUBDIR, @timestamp, "#{instance_name}.mcp.json")
+      File.join(session_path, "#{instance_name}.mcp.json")
     end
 
     private
 
-    def swarm_dir
-      File.join(Dir.pwd, SWARM_DIR)
+    def session_path
+      @session_path ||= SessionPath.from_env
     end
 
     def ensure_swarm_directory
-      FileUtils.mkdir_p(swarm_dir)
-
-      # Create session directory with timestamp
-      session_dir = File.join(swarm_dir, SESSIONS_SUBDIR, @timestamp)
-      FileUtils.mkdir_p(session_dir)
-
-      gitignore_path = File.join(swarm_dir, ".gitignore")
-      File.write(gitignore_path, "*\n") unless File.exist?(gitignore_path)
+      # Session directory is already created by orchestrator
+      # Just ensure it exists
+      SessionPath.ensure_directory(session_path)
     end
 
     def generate_mcp_config(name, instance)
@@ -55,13 +62,18 @@ module ClaudeSwarm
       # Add connection MCPs for other instances
       instance[:connections].each do |connection_name|
         connected_instance = @config.instances[connection_name]
-        mcp_servers[connection_name] = build_instance_mcp_config(connection_name, connected_instance, calling_instance: name)
+        mcp_servers[connection_name] = build_instance_mcp_config(
+          connection_name, connected_instance,
+          calling_instance: name, calling_instance_id: @instance_ids[name]
+        )
       end
 
       # Add permission MCP server if not in vibe mode (global or instance-specific)
       mcp_servers["permissions"] = build_permission_mcp_config(instance[:tools], instance[:disallowed_tools]) unless @vibe || instance[:vibe]
 
       config = {
+        "instance_id" => @instance_ids[name],
+        "instance_name" => name,
         "mcpServers" => mcp_servers
       }
 
@@ -86,7 +98,7 @@ module ClaudeSwarm
       end
     end
 
-    def build_instance_mcp_config(name, instance, calling_instance:)
+    def build_instance_mcp_config(name, instance, calling_instance:, calling_instance_id:)
       # Get the path to the claude-swarm executable
       exe_path = "claude-swarm"
 
@@ -111,8 +123,18 @@ module ClaudeSwarm
 
       args.push("--calling-instance", calling_instance) if calling_instance
 
+      args.push("--calling-instance-id", calling_instance_id) if calling_instance_id
+
+      args.push("--instance-id", @instance_ids[name]) if @instance_ids[name]
+
       args.push("--vibe") if @vibe || instance[:vibe]
 
+      # Add claude session ID if restoring
+      if @restore_states[name.to_s]
+        claude_session_id = @restore_states[name.to_s]["claude_session_id"]
+        args.push("--claude-session-id", claude_session_id) if claude_session_id
+      end
+
       {
         "type" => "stdio",
         "command" => exe_path,
@@ -120,6 +142,27 @@ module ClaudeSwarm
       }
     end
 
+    def load_instance_states
+      state_dir = File.join(@restore_session_path, "state")
+      return unless Dir.exist?(state_dir)
+
+      Dir.glob(File.join(state_dir, "*.json")).each do |state_file|
+        data = JSON.parse(File.read(state_file))
+        instance_name = data["instance_name"]
+        instance_id = data["instance_id"]
+
+        # Check both string and symbol keys since config instances might have either
+        if instance_name && (@config.instances.key?(instance_name) || @config.instances.key?(instance_name.to_sym))
+          # Store with the same key type as in @config.instances
+          key = @config.instances.key?(instance_name) ? instance_name : instance_name.to_sym
+          @instance_ids[key] = instance_id
+          @restore_states[instance_name] = data
+        end
+      rescue StandardError
+        # Skip invalid state files
+      end
+    end
+
     def build_permission_mcp_config(allowed_tools, disallowed_tools)
       exe_path = "claude-swarm"
 
@@ -134,10 +177,7 @@ module ClaudeSwarm
       {
         "type" => "stdio",
         "command" => exe_path,
-        "args" => args,
-        "env" => {
-          "CLAUDE_SWARM_SESSION_TIMESTAMP" => @timestamp
-        }
+        "args" => args
       }
     end
   end

data/lib/claude_swarm/orchestrator.rb

@@ -1,38 +1,88 @@
 # frozen_string_literal: true
 
 require "shellwords"
+require "json"
+require "fileutils"
+require_relative "session_path"
+require_relative "process_tracker"
 
 module ClaudeSwarm
   class Orchestrator
-    def initialize(configuration, mcp_generator, vibe: false, prompt: nil, session_timestamp: nil, stream_logs: false, debug: false)
+    def initialize(configuration, mcp_generator, vibe: false, prompt: nil, stream_logs: false, debug: false,
+                   restore_session_path: nil)
       @config = configuration
       @generator = mcp_generator
       @vibe = vibe
       @prompt = prompt
-      @session_timestamp = session_timestamp || Time.now.strftime("%Y%m%d_%H%M%S")
       @stream_logs = stream_logs
       @debug = debug
+      @restore_session_path = restore_session_path
     end
 
     def start
-      unless @prompt
-        puts "🐝 Starting Claude Swarm: #{@config.swarm_name}"
-        puts "😎 Vibe mode ON" if @vibe
-        puts
-      end
+      if @restore_session_path
+        unless @prompt
+          puts "🔄 Restoring Claude Swarm: #{@config.swarm_name}"
+          puts "😎 Vibe mode ON" if @vibe
+          puts
+        end
 
-      # Set session timestamp for all instances to share the same session directory
-      ENV["CLAUDE_SWARM_SESSION_TIMESTAMP"] = @session_timestamp
-      unless @prompt
-        puts "📝 Session files will be saved to: .claude-swarm/sessions/#{@session_timestamp}/"
-        puts
-      end
+        # Use existing session path
+        session_path = @restore_session_path
+        ENV["CLAUDE_SWARM_SESSION_PATH"] = session_path
+        ENV["CLAUDE_SWARM_START_DIR"] = Dir.pwd
 
-      # Generate all MCP configuration files
-      @generator.generate_all
-      unless @prompt
-        puts "✓ Generated MCP configurations in session directory"
-        puts
+        unless @prompt
+          puts "📝 Using existing session: #{session_path}/"
+          puts
+        end
+
+        # Initialize process tracker
+        @process_tracker = ProcessTracker.new(session_path)
+
+        # Set up signal handlers to clean up child processes
+        setup_signal_handlers
+
+        # Regenerate MCP configurations with session IDs for restoration
+        @generator.generate_all
+        unless @prompt
+          puts "✓ Regenerated MCP configurations with session IDs"
+          puts
+        end
+      else
+        unless @prompt
+          puts "🐝 Starting Claude Swarm: #{@config.swarm_name}"
+          puts "😎 Vibe mode ON" if @vibe
+          puts
+        end
+
+        # Generate and set session path for all instances
+        session_path = SessionPath.generate(working_dir: Dir.pwd)
+        SessionPath.ensure_directory(session_path)
+
+        ENV["CLAUDE_SWARM_SESSION_PATH"] = session_path
+        ENV["CLAUDE_SWARM_START_DIR"] = Dir.pwd
+
+        unless @prompt
+          puts "📝 Session files will be saved to: #{session_path}/"
+          puts
+        end
+
+        # Initialize process tracker
+        @process_tracker = ProcessTracker.new(session_path)
+
+        # Set up signal handlers to clean up child processes
+        setup_signal_handlers
+
+        # Generate all MCP configuration files
+        @generator.generate_all
+        unless @prompt
+          puts "✓ Generated MCP configurations in session directory"
+          puts
+        end
+
+        # Save swarm config path for restoration
+        save_swarm_config_path(session_path)
       end
 
       # Launch the main instance
@@ -64,19 +114,47 @@ module ClaudeSwarm
       end
 
       # Clean up log streaming thread
-      return unless log_thread
+      if log_thread
+        log_thread.terminate
+        log_thread.join
+      end
 
-      log_thread.terminate
-      log_thread.join
+      # Clean up child processes
+      cleanup_processes
     end
 
     private
 
+    def save_swarm_config_path(session_path)
+      # Copy the YAML config file to the session directory
+      config_copy_path = File.join(session_path, "config.yml")
+      FileUtils.cp(@config.config_path, config_copy_path)
+
+      # Save the original working directory
+      start_dir_file = File.join(session_path, "start_directory")
+      File.write(start_dir_file, Dir.pwd)
+    end
+
+    def setup_signal_handlers
+      %w[INT TERM QUIT].each do |signal|
+        Signal.trap(signal) do
+          puts "\n🛑 Received #{signal} signal, cleaning up..."
+          cleanup_processes
+          exit
+        end
+      end
+    end
+
+    def cleanup_processes
+      @process_tracker.cleanup_all
+      puts "✓ Cleanup complete"
+    rescue StandardError => e
+      puts "⚠️  Error during cleanup: #{e.message}"
+    end
+
     def start_log_streaming
       Thread.new do
-        session_log_path = File.join(Dir.pwd, ClaudeSwarm::ClaudeCodeExecutor::SWARM_DIR,
-                                     ClaudeSwarm::ClaudeCodeExecutor::SESSIONS_DIR,
-                                     @session_timestamp, "session.log")
+        session_log_path = File.join(ENV.fetch("CLAUDE_SWARM_SESSION_PATH", nil), "session.log")
 
         # Wait for log file to be created
         sleep 0.1 until File.exist?(session_log_path)
@@ -107,6 +185,26 @@ module ClaudeSwarm
         instance[:model]
       ]
 
+      # Add resume flag if restoring session
+      if @restore_session_path
+        # Look for main instance state file
+        main_instance_name = @config.main_instance
+        state_files = Dir.glob(File.join(@restore_session_path, "state", "*.json"))
+
+        # Find the state file for the main instance
+        state_files.each do |state_file|
+          state_data = JSON.parse(File.read(state_file))
+          next unless state_data["instance_name"] == main_instance_name
+
+          claude_session_id = state_data["claude_session_id"]
+          if claude_session_id
+            parts << "--resume"
+            parts << claude_session_id
+          end
+          break
+        end
+      end
+
       if @vibe || instance[:vibe]
         parts << "--dangerously-skip-permissions"
       else

data/lib/claude_swarm/permission_mcp_server.rb

@@ -5,13 +5,11 @@ require "fast_mcp"
 require "logger"
 require "fileutils"
 require_relative "permission_tool"
+require_relative "session_path"
+require_relative "process_tracker"
 
 module ClaudeSwarm
   class PermissionMcpServer
-    # Directory constants
-    SWARM_DIR = ".claude-swarm"
-    SESSIONS_DIR = "sessions"
-
     # Server configuration
     SERVER_NAME = "claude-swarm-permissions"
     SERVER_VERSION = "1.0.0"
@@ -49,6 +47,13 @@ module ClaudeSwarm
     end
 
     def create_and_start_server
+      # Track this process
+      session_path = SessionPath.from_env
+      if session_path && File.exist?(session_path)
+        tracker = ProcessTracker.new(session_path)
+        tracker.track_pid(Process.pid, "mcp_permissions")
+      end
+
       server = FastMcp::Server.new(
         name: SERVER_NAME,
         version: SERVER_VERSION
@@ -60,20 +65,14 @@ module ClaudeSwarm
     end
 
     def setup_logging
-      session_dir = create_session_directory
-      @logger = create_logger(session_dir)
+      session_path = SessionPath.from_env
+      SessionPath.ensure_directory(session_path)
+      @logger = create_logger(session_path)
       @logger.info("Permission MCP server logging initialized")
     end
 
-    def create_session_directory
-      session_timestamp = ENV["CLAUDE_SWARM_SESSION_TIMESTAMP"] || Time.now.strftime("%Y%m%d_%H%M%S")
-      session_dir = File.join(Dir.pwd, SWARM_DIR, SESSIONS_DIR, session_timestamp)
-      FileUtils.mkdir_p(session_dir)
-      session_dir
-    end
-
-    def create_logger(session_dir)
-      log_path = File.join(session_dir, "permissions.log")
+    def create_logger(session_path)
+      log_path = File.join(session_path, "permissions.log")
       logger = Logger.new(log_path)
       logger.level = Logger::DEBUG
       logger.formatter = log_formatter