bard 2.0.0.beta → 2.0.0

data/lib/bard/plugins/setup.rb

@@ -0,0 +1,54 @@
+require "uri"
+require "bard/plugins/url"
+
+class Bard::CLI
+  desc "setup", "installs app in nginx"
+  def setup
+    path = "/etc/nginx/sites-available/#{project_name}"
+    system "sudo tee #{path} >/dev/null <<-'EOF'
+upstream puma {
+    server 127.0.0.1:3000 fail_timeout=5;
+}
+
+server {
+    listen 80;
+    server_name #{nginx_server_name};
+    root #{Dir.pwd}/public;
+
+    try_files $uri @app;
+
+    location @app {
+        proxy_pass http://puma;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+
+    location ~* \\-[0-9a-f]\\{64\\}\\.(ico|css|js|gif|jpe?g|png|webp)$ {
+        access_log off;
+        expires max;
+        add_header Cache-Control public;
+    }
+
+    gzip_static on;
+}
+EOF"
+
+    dest_path = path.sub("sites-available", "sites-enabled")
+    system "sudo ln -sf #{path} #{dest_path}" if !File.exist?(dest_path)
+
+    system "sudo service nginx restart"
+  end
+
+  no_commands do
+    def nginx_server_name
+      case ENV["RAILS_ENV"]
+      when "production"
+        "*.#{URI.parse(config[:production].url).host} _"
+      when "staging" then "#{project_name}.botandrose.com"
+      else "#{project_name}.localhost"
+      end
+    end
+  end
+end

data/lib/bard/plugins/ssh/connection.rb

@@ -0,0 +1,75 @@
+require "uri"
+require "shellwords"
+require "bard/plugins/ssh/server"
+require "bard/command"
+
+module Bard
+  module SSH
+    def server
+      @server
+    end
+
+    def gateway
+      server.gateway
+    end
+
+    def ssh_key
+      server.ssh_key
+    end
+
+    def env
+      server.env
+    end
+
+    def ssh_uri
+      server.ssh_uri
+    end
+
+    def scp_uri(file_path = nil)
+      full_path = "/#{path}"
+      full_path += "/#{file_path}" if file_path
+      URI::Generic.build(scheme: "scp", userinfo: server.user, host: server.host, port: server.port.to_i, path: full_path)
+    end
+
+    def rsync_uri(file_path = nil)
+      uri = ssh_uri
+      str = "#{uri.user}@#{uri.host}"
+      str += ":#{path}"
+      str += "/#{file_path}" if file_path
+      str
+    end
+
+    def run!(command, home: false, verbose: false, quiet: false, capture: false)
+      result = Command.run!(ssh_command(command, home:), verbose:, quiet:)
+      result if capture
+    end
+
+    def run(command, home: false, verbose: false, quiet: false)
+      Command.run(ssh_command(command, home:), verbose:, quiet:)
+    end
+
+    def exec!(command, home: false)
+      Command.exec!(ssh_command(command, home:))
+    end
+
+    private
+
+    def ssh_command(command, home: false)
+      cmd = command
+      cmd = "#{env} #{command}" if env
+
+      unless home
+        cmd = "cd #{path} && #{cmd}" if path
+      end
+
+      ssh_opts = ["-tt", "-o StrictHostKeyChecking=no", "-o UserKnownHostsFile=/dev/null", "-o LogLevel=ERROR"]
+      ssh_opts << "-i #{ssh_key}" if ssh_key
+      ssh_opts << "-p #{server.port}" if server.port && server.port != "22"
+      ssh_opts << "-o ProxyJump=#{gateway}" if gateway
+
+      ssh_target = "#{server.user}@#{server.host}"
+
+      "ssh #{ssh_opts.join(" ")} #{ssh_target} #{Shellwords.shellescape(cmd)}"
+    end
+  end
+end

data/lib/bard/plugins/ssh/copy.rb

@@ -0,0 +1,95 @@
+require "uri"
+require "bard/copy"
+require "bard/command"
+
+module Bard
+  module SSH
+    class Copy < Bard::Copy
+    def self.can_handle?(from, to)
+      from.has_capability?(:ssh) || to.has_capability?(:ssh)
+    end
+
+    def file
+      if from.key == :local
+        scp_using_local :to, to
+      elsif to.key == :local
+        scp_using_local :from, from
+      else
+        scp_as_mediator
+      end
+    end
+
+    def scp_using_local direction, target
+      ssh_server = target.server
+
+      gateway = ssh_server.gateway ? "-oProxyCommand='ssh #{ssh_server.gateway} -W %h:%p'" : ""
+
+      ssh_key = ssh_server.ssh_key ? "-i #{ssh_server.ssh_key}" : ""
+
+      ssh_opts = "-o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o LogLevel=ERROR"
+
+      port = ssh_server.port
+      port_opt = port && port.to_s != "22" ? "-P #{port}" : ""
+
+      from_and_to = [path, target.scp_uri(path).to_s]
+      from_and_to.reverse! if direction == :from
+
+      command = ["scp", ssh_opts, gateway, ssh_key, port_opt, *from_and_to].reject(&:empty?).join(" ")
+      Bard::Command.run! command, verbose: verbose
+    end
+
+    def scp_as_mediator
+      from_server = from.server
+      to_server = to.server
+
+      raise NotImplementedError if from_server.gateway || to_server.gateway || from_server.ssh_key || to_server.ssh_key
+      command = "scp -o ForwardAgent=yes #{from.scp_uri(path)} #{to.scp_uri(path)}"
+      Bard::Command.run! command, verbose: verbose
+    end
+
+    def dir
+      if from.key == :local
+        rsync_using_local :to, to
+      elsif to.key == :local
+        rsync_using_local :from, from
+      else
+        rsync_as_mediator
+      end
+    end
+
+    def rsync_using_local direction, target
+      ssh_server = target.server
+
+      ssh_uri = ssh_server.ssh_uri
+
+      gateway = ssh_server.gateway ? "-oProxyCommand=\"ssh #{ssh_server.gateway} -W %h:%p\"" : ""
+
+      ssh_key = ssh_server.ssh_key ? "-i #{ssh_server.ssh_key}" : ""
+      ssh = "-e'ssh #{gateway} -p#{ssh_uri.port || 22}'"
+
+      from_and_to = ["./#{path}", target.rsync_uri(path)]
+      from_and_to.reverse! if direction == :from
+      from_and_to[-1].sub! %r(/[^/]+$), '/'
+
+      command = "rsync #{ssh} --delete --info=progress2 -az #{from_and_to.join(" ")}"
+      Bard::Command.run! command, verbose: verbose
+    end
+
+    def rsync_as_mediator
+      from_server = from.server
+      to_server = to.server
+
+      raise NotImplementedError if from_server.gateway || to_server.gateway || from_server.ssh_key || to_server.ssh_key
+
+      from_uri = from_server.ssh_uri
+      to_uri = to_server.ssh_uri
+
+      from_str = "-p#{from_uri.port || 22} #{from_uri.user}@#{from_uri.host}"
+      to_str = to.rsync_uri(path).sub(%r(/[^/]+$), '/')
+
+      command = %(ssh -A #{from_str} 'rsync -e \"ssh -A -p#{to_uri.port || 22} -o StrictHostKeyChecking=no -o LogLevel=ERROR\" --delete --info=progress2 -az #{from.path}/#{path} #{to_str}')
+      Bard::Command.run! command, verbose: verbose
+    end
+    end
+  end
+end

data/lib/bard/{ssh_server.rb → plugins/ssh/server.rb}

@@ -1,5 +1,4 @@
 require "uri"
-require "bard/command"
 
 module Bard
   class SSHServer
@@ -9,13 +8,11 @@ module Bard
       @uri_string = uri_string
       @options = options
 
-      # Parse URI
       uri = parse_uri(uri_string)
       @user = uri.user || ENV['USER']
       @host = uri.host
       @port = uri.port ? uri.port.to_s : "22"
 
-      # Store options
       @path = options[:path]
       @gateway = options[:gateway]
       @ssh_key = options[:ssh_key]
@@ -23,39 +20,42 @@ module Bard
     end
 
     def ssh_uri
-      "#{user}@#{host}:#{port}"
+      URI("ssh://#{user}@#{host}:#{port}")
     end
 
     def hostname
       host
     end
 
+    def to_s
+      str = "#{user}@#{host}"
+      str += ":#{port}" if port && port != "22"
+      str
+    end
+
     def connection_string
       "#{user}@#{host}"
     end
 
-    def run(command)
-      full_command = build_command(command)
-      Open3.capture3(full_command)
+    def ==(other)
+      return false unless other.is_a?(Bard::SSHServer)
+      state == other.state
     end
+    alias_method :eql?, :==
 
-    def run!(command)
-      output, error, status = run(command)
-      if status.to_i.nonzero?
-        raise Command::Error, "Command failed: #{command}\n#{error}"
-      end
-      output
+    def hash
+      state.hash
     end
 
-    def exec!(command)
-      full_command = build_command(command)
-      exec(full_command)
+    protected
+
+    def state
+      [user, host, port, path, gateway, ssh_key, env]
     end
 
     private
 
     def parse_uri(uri_string)
-      # Handle user@host:port format
       if uri_string =~ /^([^@]+@)?([^:]+)(?::(\d+))?$/
         user_part = $1&.chomp('@')
         host_part = $2
@@ -71,30 +71,5 @@ module Bard
         URI.parse("ssh://#{uri_string}")
       end
     end
-
-    def build_command(command)
-      cmd = "ssh -tt"
-
-      # Add port
-      cmd += " -p #{port}" if port != "22"
-
-      # Add gateway
-      cmd += " -o ProxyJump=#{gateway}" if gateway
-
-      # Add SSH key
-      cmd += " -i #{ssh_key}" if ssh_key
-
-      # Add user@host
-      cmd += " #{user}@#{host}"
-
-      # Add command with path and env
-      remote_cmd = ""
-      remote_cmd += "#{env} " if env
-      remote_cmd += "cd #{path} && " if path
-      remote_cmd += command
-
-      cmd += " '#{remote_cmd}'"
-      cmd
-    end
   end
 end

data/lib/bard/plugins/ssh/target_methods.rb

@@ -0,0 +1,20 @@
+require "bard/target"
+require "bard/plugins/url/target_methods"
+require "bard/plugins/ssh/connection"
+
+class Bard::Target
+  def ssh(uri = nil, **options)
+    if uri.nil?
+      return @server
+    else
+      extend Bard::SSH
+
+      @server = Bard::SSHServer.new(uri, **options)
+      @path = options[:path] if options[:path]
+      enable_capability(:ssh)
+
+      hostname = @server.hostname
+      url("https://#{hostname}") if hostname
+    end
+  end
+end

data/lib/bard/plugins/ssh.rb

@@ -0,0 +1,10 @@
+require "bard/plugins/ssh/target_methods"
+require "bard/plugins/ssh/copy"
+
+class Bard::CLI
+  option :home, type: :boolean
+  desc "ssh [to=production]", "logs into the specified server via SSH"
+  def ssh(to = :production)
+    config[to].exec! "exec $SHELL -l", home: options[:home]
+  end
+end

data/lib/bard/plugins/url/target_methods.rb

@@ -0,0 +1,23 @@
+require "bard/target"
+
+class Bard::Target
+  def url(value = nil)
+    if value.nil?
+      @url
+    elsif value == false
+      @url = nil
+      @capabilities.delete(:url)
+    else
+      @url = normalize_url(value)
+      enable_capability(:url)
+    end
+  end
+
+  private
+
+  def normalize_url(value)
+    normalized = value.to_s
+    normalized = "https://#{normalized}" unless normalized.start_with?("http")
+    normalized
+  end
+end

data/lib/bard/plugins/url.rb

@@ -0,0 +1 @@
+require "bard/plugins/url/target_methods"

data/lib/bard/plugins/vim.rb

@@ -0,0 +1,6 @@
+class Bard::CLI
+  desc "vim [branch=master]", "open all files that have changed since master"
+  def vim(branch = "master")
+    exec "vim -p `(git diff #{branch} --name-only; git ls-files --others --exclude-standard) | grep -v '^app/assets/images/' | grep -v '^app/assets/stylesheets/' | while read f; do [ -f \"$f\" ] && ! file -b \"$f\" | grep -q \"binary\" && echo \"$f\"; done | tac`"
+  end
+end

data/lib/bard/retryable.rb

@@ -0,0 +1,25 @@
+module Bard
+  module Retryable
+    MAX_RETRIES = 5
+    INITIAL_DELAY = 1
+
+    def retry_with_backoff(max_retries: MAX_RETRIES)
+      retries = 0
+      delay = INITIAL_DELAY
+
+      begin
+        yield
+      rescue => e
+        if retries < max_retries
+          retries += 1
+          puts "  Network error (attempt #{retries}/#{max_retries}): #{e.message}. Retrying in #{delay}s..."
+          sleep(delay)
+          delay *= 2
+          retry
+        else
+          raise "Network error after #{max_retries} attempts: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/bard/secrets.rb

@@ -0,0 +1,10 @@
+module Bard
+  module Secrets
+    REPO = "git@github.com:botandrosedesign/secrets"
+
+    def self.fetch(key)
+      raw = `git ls-remote -t #{REPO}`
+      raw[/#{Regexp.escape(key)}\|(.+)$/, 1]
+    end
+  end
+end

data/lib/bard/target.rb

@@ -1,22 +1,14 @@
-require "uri"
 require "bard/command"
-require "bard/copy"
-require "bard/deploy_strategy"
 
 module Bard
   class Target
-    attr_reader :key, :config, :path
-    attr_accessor :server, :gateway, :ssh_key, :env
+    attr_reader :key, :config
 
     def initialize(key, config)
       @key = key
       @config = config
       @capabilities = []
-      @ping_urls = []
-      @strategy_options_hash = {}
-      @deploy_strategy = nil
       @path = nil
-      @server = nil
     end
 
     # Capability tracking
@@ -30,193 +22,25 @@ module Bard
 
     def require_capability!(capability)
       unless has_capability?(capability)
-        error_message = case capability
-        when :ssh
-          "SSH not configured for this target"
-        when :ping
-          "Ping URL not configured for this target"
-        else
-          "#{capability} capability not configured for this target"
-        end
-        raise error_message
-      end
-    end
-
-    # SSH configuration
-    def ssh(uri_or_false = nil, **options)
-      if uri_or_false.nil?
-        # Getter - return false if explicitly disabled, otherwise return server
-        return @ssh_disabled ? false : @server
-      elsif uri_or_false == false
-        # Disable SSH
-        @server = nil
-        @ssh_disabled = true
-        @capabilities.delete(:ssh)
-      else
-        # Enable SSH
-        require "bard/ssh_server"
-        @server = SSHServer.new(uri_or_false, **options)
-        @path = options[:path] if options[:path]
-        @gateway = options[:gateway] if options[:gateway]
-        @ssh_key = options[:ssh_key] if options[:ssh_key]
-        @env = options[:env] if options[:env]
-        enable_capability(:ssh)
-
-        # Set SSH as default deployment strategy if none set
-        @deploy_strategy ||= :ssh
-
-        # Auto-configure ping from hostname
-        hostname = @server.hostname
-        ping(hostname) if hostname
-      end
-    end
-
-    def ssh_uri
-      server&.ssh_uri
-    end
-
-    # Path configuration
-    def path(new_path = nil)
-      if new_path
-        @path = new_path
-      else
-        @path || config.project_name
-      end
-    end
-
-    # Ping configuration
-    def ping(*urls)
-      if urls.empty?
-        # Getter
-        @ping_urls
-      elsif urls.first == false
-        # Disable ping
-        @ping_urls = []
-        @capabilities.delete(:ping)
-      else
-        # Enable ping
-        @ping_urls = urls.flatten
-        enable_capability(:ping)
-      end
-    end
-
-    def ping_urls
-      @ping_urls
-    end
-
-    def ping!
-      require_capability!(:ping)
-      require "bard/ping"
-      failed_urls = Bard::Ping.call(self)
-      if failed_urls.any?
-        raise "Ping failed for: #{failed_urls.join(', ')}"
-      end
-    end
-
-    def open
-      require_capability!(:ping)
-      system "open #{ping_urls.first}"
-    end
-
-    # Deploy strategy
-    attr_reader :deploy_strategy
-
-    # GitHub Pages deployment configuration
-    def github_pages(url = nil)
-      if url.nil?
-        # Getter
-        @github_pages_url
-      else
-        # Setter
-        @deploy_strategy = :github_pages
-        @github_pages_url = url
-        enable_capability(:github_pages)
-      end
-    end
-
-    def strategy_options(strategy_name)
-      @strategy_options_hash[strategy_name] || {}
-    end
-
-    def deploy_strategy_instance
-      raise "No deployment strategy configured for target #{key}" unless @deploy_strategy
-
-      strategy_class = DeployStrategy[@deploy_strategy]
-      raise "Unknown deployment strategy: #{@deploy_strategy}" unless strategy_class
-
-      strategy_class.new(self)
-    end
-
-    # Dynamic strategy DSL via method_missing
-    def method_missing(method, *args, **kwargs, &block)
-      strategy_class = DeployStrategy[method]
-
-      if strategy_class
-        # This is a deployment strategy
-        @deploy_strategy = method
-
-        # Store options
-        @strategy_options_hash[method] = kwargs
-
-        # Auto-configure ping if first arg is a URL
-        if args.first && args.first.to_s =~ /^https?:\/\//
-          ping(args.first)
-        end
-
-        # Call the strategy's initializer if it wants to configure the target
-        # (This will be handled by the strategy class)
-      else
-        super
+        raise "#{capability} capability not configured for this target"
       end
     end
 
-    def respond_to_missing?(method, include_private = false)
-      DeployStrategy[method] || super
+    def path
+      @path || config.project_name
     end
 
-    # Remote command execution
-    def run!(command, home: false, verbose: false, quiet: false)
-      require_capability!(:ssh)
-      Command.run!(command, on: server, home: home, verbose: verbose, quiet: quiet)
+    def run!(command, home: false, verbose: false, quiet: false, capture: false)
+      result = Command.run!(command, verbose:, quiet:)
+      result if capture
     end
 
     def run(command, home: false, verbose: false, quiet: false)
-      require_capability!(:ssh)
-      Command.run(command, on: server, home: home, verbose: verbose, quiet: quiet)
+      Command.run(command, verbose:, quiet:)
     end
 
     def exec!(command, home: false)
-      require_capability!(:ssh)
-      Command.exec!(command, on: server, home: home)
-    end
-
-    # File transfer
-    def copy_file(path, to:, verbose: false)
-      require_capability!(:ssh)
-      to.require_capability!(:ssh)
-      Copy.file(path, from: self, to: to, verbose: verbose)
-    end
-
-    def copy_dir(path, to:, verbose: false)
-      require_capability!(:ssh)
-      to.require_capability!(:ssh)
-      Copy.dir(path, from: self, to: to, verbose: verbose)
-    end
-
-    # URI methods for compatibility
-    def scp_uri(file_path = nil)
-      uri = URI("scp://#{ssh_uri}")
-      uri.path = "/#{path}"
-      uri.path += "/#{file_path}" if file_path
-      uri
-    end
-
-    def rsync_uri(file_path = nil)
-      uri = URI("ssh://#{ssh_uri}")
-      str = "#{uri.user}@#{uri.host}"
-      str += ":#{path}"
-      str += "/#{file_path}" if file_path
-      str
+      Command.exec!(command)
     end
 
     # Utility methods
@@ -235,5 +59,23 @@ module Bard
         end
       end
     end
+
+    def ==(other)
+      return false unless other.is_a?(Bard::Target)
+      comparable_state == other.comparable_state
+    end
+    alias_method :eql?, :==
+
+    def hash
+      comparable_state.hash
+    end
+
+    protected
+
+    def comparable_state
+      (instance_variables - [:@key, :@config]).sort.map do |ivar|
+        [ivar, instance_variable_get(ivar)]
+      end
+    end
   end
 end

data/lib/bard/version.rb

@@ -1,4 +1,4 @@
 module Bard
-  VERSION = "2.0.0.beta"
+  VERSION = "2.0.0"
 end
 

data/lib/bard.rb

@@ -1,3 +1 @@
-module Bard
-end
-
+require "bard/cli"