claude_swarm 0.1.15 → 0.1.17

data/lib/claude_swarm/orchestrator.rb

@@ -8,6 +8,8 @@ require_relative "process_tracker"
 
 module ClaudeSwarm
   class Orchestrator
+    RUN_DIR = File.expand_path("~/.claude-swarm/run")
+
     def initialize(configuration, mcp_generator, vibe: false, prompt: nil, stream_logs: false, debug: false,
                    restore_session_path: nil)
       @config = configuration
@@ -17,6 +19,7 @@ module ClaudeSwarm
       @stream_logs = stream_logs
       @debug = debug
       @restore_session_path = restore_session_path
+      @session_path = nil
     end
 
     def start
@@ -29,9 +32,13 @@ module ClaudeSwarm
 
         # Use existing session path
         session_path = @restore_session_path
+        @session_path = session_path
         ENV["CLAUDE_SWARM_SESSION_PATH"] = session_path
         ENV["CLAUDE_SWARM_START_DIR"] = Dir.pwd
 
+        # Create run symlink for restored session
+        create_run_symlink
+
         unless @prompt
           puts "📝 Using existing session: #{session_path}/"
           puts
@@ -59,10 +66,14 @@ module ClaudeSwarm
         # Generate and set session path for all instances
         session_path = SessionPath.generate(working_dir: Dir.pwd)
         SessionPath.ensure_directory(session_path)
+        @session_path = session_path
 
         ENV["CLAUDE_SWARM_SESSION_PATH"] = session_path
         ENV["CLAUDE_SWARM_START_DIR"] = Dir.pwd
 
+        # Create run symlink for new session
+        create_run_symlink
+
         unless @prompt
           puts "📝 Session files will be saved to: #{session_path}/"
           puts
@@ -90,8 +101,13 @@ module ClaudeSwarm
       unless @prompt
         puts "🚀 Launching main instance: #{@config.main_instance}"
         puts "   Model: #{main_instance[:model]}"
-        puts "   Directory: #{main_instance[:directory]}"
-        puts "   Allowed tools: #{main_instance[:tools].join(", ")}" if main_instance[:tools].any?
+        if main_instance[:directories].size == 1
+          puts "   Directory: #{main_instance[:directory]}"
+        else
+          puts "   Directories:"
+          main_instance[:directories].each { |dir| puts "     - #{dir}" }
+        end
+        puts "   Allowed tools: #{main_instance[:allowed_tools].join(", ")}" if main_instance[:allowed_tools].any?
         puts "   Disallowed tools: #{main_instance[:disallowed_tools].join(", ")}" if main_instance[:disallowed_tools]&.any?
         puts "   Connections: #{main_instance[:connections].join(", ")}" if main_instance[:connections].any?
         puts "   😎 Vibe mode ON for this instance" if main_instance[:vibe]
@@ -119,8 +135,9 @@ module ClaudeSwarm
         log_thread.join
       end
 
-      # Clean up child processes
+      # Clean up child processes and run symlink
       cleanup_processes
+      cleanup_run_symlink
     end
 
     private
@@ -140,6 +157,7 @@ module ClaudeSwarm
         Signal.trap(signal) do
           puts "\n🛑 Received #{signal} signal, cleaning up..."
           cleanup_processes
+          cleanup_run_symlink
           exit
         end
       end
@@ -152,6 +170,35 @@ module ClaudeSwarm
       puts "⚠️  Error during cleanup: #{e.message}"
     end
 
+    def create_run_symlink
+      return unless @session_path
+
+      FileUtils.mkdir_p(RUN_DIR)
+
+      # Session ID is the last part of the session path
+      session_id = File.basename(@session_path)
+      symlink_path = File.join(RUN_DIR, session_id)
+
+      # Remove stale symlink if exists
+      File.unlink(symlink_path) if File.symlink?(symlink_path)
+
+      # Create new symlink
+      File.symlink(@session_path, symlink_path)
+    rescue StandardError => e
+      # Don't fail the process if symlink creation fails
+      puts "⚠️  Warning: Could not create run symlink: #{e.message}" unless @prompt
+    end
+
+    def cleanup_run_symlink
+      return unless @session_path
+
+      session_id = File.basename(@session_path)
+      symlink_path = File.join(RUN_DIR, session_id)
+      File.unlink(symlink_path) if File.symlink?(symlink_path)
+    rescue StandardError
+      # Ignore errors during cleanup
+    end
+
     def start_log_streaming
       Thread.new do
         session_log_path = File.join(ENV.fetch("CLAUDE_SWARM_SESSION_PATH", nil), "session.log")
@@ -208,9 +255,17 @@ module ClaudeSwarm
       if @vibe || instance[:vibe]
         parts << "--dangerously-skip-permissions"
       else
+        # Build allowed tools list including MCP connections
+        allowed_tools = instance[:allowed_tools].dup
+
+        # Add mcp__instance_name for each connection
+        instance[:connections].each do |connection_name|
+          allowed_tools << "mcp__#{connection_name}"
+        end
+
         # Add allowed tools if any
-        if instance[:tools].any?
-          tools_str = instance[:tools].join(",")
+        if allowed_tools.any?
+          tools_str = allowed_tools.join(",")
           parts << "--allowedTools"
           parts << tools_str
         end
@@ -221,10 +276,6 @@ module ClaudeSwarm
           parts << "--disallowedTools"
           parts << disallowed_tools_str
         end
-
-        # Add permission prompt tool unless in vibe mode
-        parts << "--permission-prompt-tool"
-        parts << "mcp__permissions__check_permission"
       end
 
       if instance[:prompt]
@@ -234,6 +285,14 @@ module ClaudeSwarm
 
       parts << "--debug" if @debug
 
+      # Add additional directories with --add-dir
+      if instance[:directories].size > 1
+        instance[:directories][1..].each do |additional_dir|
+          parts << "--add-dir"
+          parts << additional_dir
+        end
+      end
+
       mcp_config_path = @generator.mcp_config_path(@config.main_instance)
       parts << "--mcp-config"
       parts << mcp_config_path

data/lib/claude_swarm/task_tool.rb

@@ -4,7 +4,7 @@ module ClaudeSwarm
   class TaskTool < FastMcp::Tool
     tool_name "task"
     description "Execute a task using Claude Code. There is no description parameter."
-    annotations(readOnlyHint: true, openWorldHint: false, destructiveHint: false)
+    annotations(read_only_hint: true, open_world_hint: false, destructive_hint: false)
 
     arguments do
       required(:prompt).filled(:string).description("The task or question for the agent")
@@ -22,11 +22,14 @@ module ClaudeSwarm
       }
 
       # Add allowed tools from instance config
-      options[:allowed_tools] = instance_config[:tools] if instance_config[:tools]&.any?
+      options[:allowed_tools] = instance_config[:allowed_tools] if instance_config[:allowed_tools]&.any?
 
       # Add disallowed tools from instance config
       options[:disallowed_tools] = instance_config[:disallowed_tools] if instance_config[:disallowed_tools]&.any?
 
+      # Add connections from instance config
+      options[:connections] = instance_config[:connections] if instance_config[:connections]&.any?
+
       response = executor.execute(prompt, options)
 
       # Return just the result text as expected by MCP

data/lib/claude_swarm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ClaudeSwarm
-  VERSION = "0.1.15"
+  VERSION = "0.1.17"
 end

data/lib/claude_swarm.rb

@@ -7,8 +7,6 @@ require_relative "claude_swarm/mcp_generator"
 require_relative "claude_swarm/orchestrator"
 require_relative "claude_swarm/claude_code_executor"
 require_relative "claude_swarm/claude_mcp_server"
-require_relative "claude_swarm/permission_tool"
-require_relative "claude_swarm/permission_mcp_server"
 require_relative "claude_swarm/session_path"
 require_relative "claude_swarm/session_info_tool"
 require_relative "claude_swarm/reset_session_tool"

data/llms.txt

@@ -225,10 +225,10 @@ cat ~/.claude-swarm/sessions/PROJECT/TIMESTAMP/session.log.json
 - Check `main:` references valid instance key
 **"Circular dependency detected"**
 - Remove circular connections between instances
-**"Permission denied for tool X"**
+**"Tool not allowed"**
 - Check `allowed_tools` includes the tool
 - Check `disallowed_tools` doesn't block it
-- Use `--vibe` to skip permissions (dangerous)
+- Use `vibe: true` to skip all checks (dangerous)
 **"MCP server failed to start"**
 - Check the command/URL is correct
 - Verify MCP server is installed
@@ -362,12 +362,11 @@ bundle exec rake release
 - `CLAUDE_SWARM_HOME`: Override session storage location (default: ~/.claude-swarm)
 - `ANTHROPIC_MODEL`: Default Claude model if not specified
 ## Security Considerations
-- Tool restrictions enforced at permission layer
-- All permissions logged for audit
+- Tool restrictions enforced through configuration
 - Vibe mode bypasses ALL restrictions - use carefully
 - Session files may contain sensitive data
 - Each instance runs with its directory context
-- MCP servers inherit instance permissions
+- MCP servers inherit instance tool configurations
 ## Limitations
 - Tree hierarchy only (no circular dependencies)
 - Session restoration is experimental

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: claude_swarm
 version: !ruby/object:Gem::Version
-  version: 0.1.15
+  version: 0.1.17
 platform: ruby
 authors:
 - Paulo Arruda
@@ -59,21 +59,24 @@ files:
 - README.md
 - RELEASING.md
 - Rakefile
+- claude-sdk-docs.md
 - claude-swarm.yml
 - example/claude-swarm.yml
 - example/microservices-team.yml
 - example/session-restoration-demo.yml
 - example/test-generation.yml
+- examples/monitoring-demo.yml
+- examples/multi-directory.yml
 - exe/claude-swarm
 - lib/claude_swarm.rb
 - lib/claude_swarm/claude_code_executor.rb
 - lib/claude_swarm/claude_mcp_server.rb
 - lib/claude_swarm/cli.rb
+- lib/claude_swarm/commands/ps.rb
+- lib/claude_swarm/commands/show.rb
 - lib/claude_swarm/configuration.rb
 - lib/claude_swarm/mcp_generator.rb
 - lib/claude_swarm/orchestrator.rb
-- lib/claude_swarm/permission_mcp_server.rb
-- lib/claude_swarm/permission_tool.rb
 - lib/claude_swarm/process_tracker.rb
 - lib/claude_swarm/reset_session_tool.rb
 - lib/claude_swarm/session_info_tool.rb
@@ -81,7 +84,6 @@ files:
 - lib/claude_swarm/task_tool.rb
 - lib/claude_swarm/version.rb
 - llms.txt
-- sdk-docs.md
 homepage: https://github.com/parruda/claude-swarm
 licenses: []
 metadata:

data/lib/claude_swarm/permission_mcp_server.rb

@@ -1,189 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "fast_mcp_annotations"
-require "logger"
-require "fileutils"
-require_relative "permission_tool"
-require_relative "session_path"
-require_relative "process_tracker"
-
-module ClaudeSwarm
-  class PermissionMcpServer
-    # Server configuration
-    SERVER_NAME = "claude-swarm-permissions"
-    SERVER_VERSION = "1.0.0"
-
-    # Tool categories
-    FILE_TOOLS = %w[Read Write Edit].freeze
-    BASH_TOOL = "Bash"
-
-    # Pattern matching
-    TOOL_PATTERN_REGEX = /^([^()]+)\(([^)]+)\)$/
-    PARAM_PATTERN_REGEX = /^(\w+)\s*:\s*(.+)$/
-
-    def initialize(allowed_tools: nil, disallowed_tools: nil)
-      @allowed_tools = allowed_tools
-      @disallowed_tools = disallowed_tools
-      setup_logging
-    end
-
-    def start
-      configure_permission_tool
-      create_and_start_server
-    end
-
-    private
-
-    def configure_permission_tool
-      allowed_patterns = parse_tool_patterns(@allowed_tools)
-      disallowed_patterns = parse_tool_patterns(@disallowed_tools)
-
-      log_configuration(allowed_patterns, disallowed_patterns)
-
-      PermissionTool.allowed_patterns = allowed_patterns
-      PermissionTool.disallowed_patterns = disallowed_patterns
-      PermissionTool.logger = @logger
-    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
-      )
-
-      server.register_tool(PermissionTool)
-      @logger.info("Permission MCP server started successfully")
-      server.start
-    end
-
-    def setup_logging
-      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_logger(session_path)
-      log_path = File.join(session_path, "permissions.log")
-      logger = Logger.new(log_path)
-      logger.level = Logger::DEBUG
-      logger.formatter = log_formatter
-      logger
-    end
-
-    def log_formatter
-      proc do |severity, datetime, _progname, msg|
-        "[#{datetime.strftime("%Y-%m-%d %H:%M:%S.%L")}] [#{severity}] #{msg}\n"
-      end
-    end
-
-    def log_configuration(allowed_patterns, disallowed_patterns)
-      @logger.info("Starting permission MCP server with allowed patterns: #{allowed_patterns.inspect}, " \
-                   "disallowed patterns: #{disallowed_patterns.inspect}")
-    end
-
-    def parse_tool_patterns(tools)
-      return [] if tools.nil? || tools.empty?
-
-      normalize_tool_list(tools).filter_map do |tool|
-        parse_single_tool_pattern(tool.strip)
-      end
-    end
-
-    def normalize_tool_list(tools)
-      tools.is_a?(Array) ? tools : tools.split(/[,\s]+/)
-    end
-
-    def parse_single_tool_pattern(tool)
-      return nil if tool.empty?
-
-      if (match = tool.match(TOOL_PATTERN_REGEX))
-        parse_tool_with_pattern(match[1], match[2])
-      elsif tool.include?("*")
-        create_wildcard_tool_pattern(tool)
-      else
-        create_exact_tool_pattern(tool)
-      end
-    end
-
-    def parse_tool_with_pattern(tool_name, pattern)
-      case tool_name
-      when *FILE_TOOLS
-        create_file_tool_pattern(tool_name, pattern)
-      when BASH_TOOL
-        create_bash_tool_pattern(tool_name, pattern)
-      else
-        create_custom_tool_pattern(tool_name, pattern)
-      end
-    end
-
-    def create_file_tool_pattern(tool_name, pattern)
-      {
-        tool_name: tool_name,
-        pattern: File.expand_path(pattern),
-        type: :glob
-      }
-    end
-
-    def create_bash_tool_pattern(tool_name, pattern)
-      {
-        tool_name: tool_name,
-        pattern: process_bash_pattern(pattern),
-        type: :regex
-      }
-    end
-
-    def process_bash_pattern(pattern)
-      if pattern.include?(":")
-        # Colon syntax: convert parts and join with spaces
-        pattern.split(":")
-               .map { |part| part.gsub("*", ".*") }
-               .join(" ")
-      else
-        # Literal pattern: escape asterisks
-        pattern.gsub("*", "\\*")
-      end
-    end
-
-    def create_custom_tool_pattern(tool_name, pattern)
-      {
-        tool_name: tool_name,
-        pattern: parse_parameter_patterns(pattern),
-        type: :params
-      }
-    end
-
-    def parse_parameter_patterns(pattern)
-      pattern.split(",").each_with_object({}) do |param_pair, params|
-        param_pair = param_pair.strip
-        if (match = param_pair.match(PARAM_PATTERN_REGEX))
-          params[match[1]] = match[2]
-        end
-      end
-    end
-
-    def create_wildcard_tool_pattern(tool)
-      {
-        tool_name: tool.gsub("*", ".*"),
-        pattern: nil,
-        type: :regex
-      }
-    end
-
-    def create_exact_tool_pattern(tool)
-      {
-        tool_name: tool,
-        pattern: nil,
-        type: :exact
-      }
-    end
-  end
-end

data/lib/claude_swarm/permission_tool.rb

@@ -1,201 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "fast_mcp_annotations"
-
-module ClaudeSwarm
-  class PermissionTool < FastMcp::Tool
-    # Class variables to store allowed/disallowed patterns and logger
-    class << self
-      attr_accessor :allowed_patterns, :disallowed_patterns, :logger
-    end
-
-    # Tool categories
-    FILE_TOOLS = %w[Read Write Edit].freeze
-    BASH_TOOL = "Bash"
-
-    # Response behaviors
-    BEHAVIOR_ALLOW = "allow"
-    BEHAVIOR_DENY = "deny"
-
-    # File matching flags
-    FILE_MATCH_FLAGS = File::FNM_DOTMATCH | File::FNM_PATHNAME | File::FNM_EXTGLOB
-
-    tool_name "check_permission"
-    description "Check if a tool is allowed to be used based on configured patterns"
-
-    arguments do
-      required(:tool_name).filled(:string).description("The tool requesting permission")
-      required(:input).value(:hash).description("The input for the tool")
-    end
-
-    def call(tool_name:, input:)
-      @current_tool_name = tool_name
-      log_request(tool_name, input)
-
-      result = evaluate_permission(tool_name, input)
-      response = JSON.generate(result)
-
-      log_response(response)
-      response
-    end
-
-    private
-
-    def evaluate_permission(tool_name, input)
-      if explicitly_disallowed?(tool_name, input)
-        deny_response(tool_name, "explicitly disallowed")
-      elsif implicitly_allowed?(tool_name, input)
-        allow_response(input)
-      else
-        deny_response(tool_name, "not allowed by configured patterns")
-      end
-    end
-
-    def explicitly_disallowed?(tool_name, input)
-      check_patterns(disallowed_patterns, tool_name, input, "Disallowed")
-    end
-
-    def implicitly_allowed?(tool_name, input)
-      allowed_patterns.empty? || check_patterns(allowed_patterns, tool_name, input, "Allowed")
-    end
-
-    def check_patterns(patterns, tool_name, input, pattern_type)
-      patterns.any? do |pattern_hash|
-        match = matches_pattern?(tool_name, input, pattern_hash)
-        log_pattern_check(pattern_type, pattern_hash, tool_name, input, match)
-        match
-      end
-    end
-
-    def matches_pattern?(tool_name, input, pattern_hash)
-      return false unless tool_name_matches?(tool_name, pattern_hash)
-      return true if pattern_hash[:pattern].nil?
-
-      match_tool_specific_pattern(tool_name, input, pattern_hash)
-    end
-
-    def tool_name_matches?(tool_name, pattern_hash)
-      case pattern_hash[:type]
-      when :regex
-        tool_name.match?(/^#{pattern_hash[:tool_name]}$/)
-      else
-        tool_name == pattern_hash[:tool_name]
-      end
-    end
-
-    def match_tool_specific_pattern(_tool_name, input, pattern_hash)
-      case pattern_hash[:tool_name]
-      when BASH_TOOL
-        match_bash_pattern(input, pattern_hash)
-      when *FILE_TOOLS
-        match_file_pattern(input, pattern_hash[:pattern])
-      else
-        match_custom_tool_pattern(input, pattern_hash)
-      end
-    end
-
-    def match_bash_pattern(input, pattern_hash)
-      command = extract_field_value(input, "command")
-      return false unless command
-
-      if pattern_hash[:type] == :regex
-        command.match?(/^#{pattern_hash[:pattern]}$/)
-      else
-        command == pattern_hash[:pattern]
-      end
-    end
-
-    def match_file_pattern(input, pattern)
-      file_path = extract_field_value(input, "file_path")
-      unless file_path
-        log_missing_field("file_path", input)
-        return false
-      end
-
-      File.fnmatch(pattern, File.expand_path(file_path), FILE_MATCH_FLAGS)
-    end
-
-    def match_custom_tool_pattern(input, pattern_hash)
-      return false unless pattern_hash[:type] == :params && pattern_hash[:pattern].is_a?(Hash)
-      return false if pattern_hash[:pattern].empty?
-
-      match_parameter_patterns(input, pattern_hash[:pattern])
-    end
-
-    def match_parameter_patterns(input, param_patterns)
-      param_patterns.all? do |param_name, param_pattern|
-        value = extract_field_value(input, param_name.to_s)
-        return false unless value
-
-        regex_pattern = glob_to_regex(param_pattern)
-        value.to_s.match?(/^#{regex_pattern}$/)
-      end
-    end
-
-    def extract_field_value(input, field_name)
-      input[field_name] || input[field_name.to_sym]
-    end
-
-    def glob_to_regex(pattern)
-      Regexp.escape(pattern)
-            .gsub('\*', ".*")
-            .gsub('\?', ".")
-    end
-
-    # Response builders
-    def allow_response(input)
-      log_decision("ALLOWED", "matches configured patterns")
-      {
-        "behavior" => BEHAVIOR_ALLOW,
-        "updatedInput" => input
-      }
-    end
-
-    def deny_response(tool_name, reason)
-      log_decision("DENIED", "is #{reason}")
-      {
-        "behavior" => BEHAVIOR_DENY,
-        "message" => "Tool '#{tool_name}' is #{reason}"
-      }
-    end
-
-    # Logging helpers
-    def log_request(tool_name, input)
-      logger&.info("Permission check requested for tool: #{tool_name}")
-      logger&.info("Tool input: #{input.inspect}")
-      logger&.info("Checking against allowed patterns: #{allowed_patterns.inspect}")
-      logger&.info("Checking against disallowed patterns: #{disallowed_patterns.inspect}")
-    end
-
-    def log_response(response)
-      logger&.info("Returning response: #{response}")
-    end
-
-    def log_pattern_check(pattern_type, pattern_hash, tool_name, input, match)
-      logger&.info("#{pattern_type} pattern '#{pattern_hash.inspect}' vs '#{tool_name}' " \
-                   "with input '#{input.inspect}': #{match}")
-    end
-
-    def log_decision(status, reason)
-      logger&.info("#{status}: Tool '#{@current_tool_name}' #{reason}")
-    end
-
-    def log_missing_field(field_name, input)
-      logger&.info("#{field_name} not found in input: #{input.inspect}")
-    end
-
-    # Convenience accessors
-    def logger
-      self.class.logger
-    end
-
-    def allowed_patterns
-      self.class.allowed_patterns || []
-    end
-
-    def disallowed_patterns
-      self.class.disallowed_patterns || []
-    end
-  end
-end