openclacky 1.0.0 → 1.0.2

data/lib/clacky/default_skills/deploy/tools/check_health.rb

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-require 'net/http'
-require 'uri'
-require 'json'
-
-module Clacky
-  module DeployTools
-    # Perform HTTP health check on deployed application
-    class CheckHealth
-      DEFAULT_PATH = '/'
-      DEFAULT_TIMEOUT = 30
-      MAX_TIMEOUT = 120
-
-      # Perform health check
-      #
-      # @param url [String] Optional URL (defaults to RAILWAY_PUBLIC_DOMAIN env var)
-      # @param path [String] Health check path (default: "/")
-      # @param timeout [Integer] Request timeout in seconds (default: 30)
-      # @return [Hash] Result of health check
-      def self.execute(url: nil, path: DEFAULT_PATH, timeout: DEFAULT_TIMEOUT)
-        # Get URL from parameter or environment
-        target_url = url || ENV['RAILWAY_PUBLIC_DOMAIN']
-        
-        if target_url.nil? || target_url.empty?
-          return {
-            error: "No URL provided",
-            details: "Please provide a URL or set RAILWAY_PUBLIC_DOMAIN environment variable"
-          }
-        end
-
-        # Ensure URL has protocol
-        target_url = "https://#{target_url}" unless target_url.start_with?('http://', 'https://')
-
-        # Build full URL with path
-        full_url = "#{target_url.chomp('/')}#{path}"
-
-        # Validate timeout
-        timeout = timeout.to_i
-        if timeout <= 0 || timeout > MAX_TIMEOUT
-          timeout = DEFAULT_TIMEOUT
-        end
-
-        puts "🏥 Checking health: #{full_url} (timeout: #{timeout}s)"
-
-        begin
-          uri = URI.parse(full_url)
-          result = perform_request(uri, timeout)
-          
-          if result[:success]
-            puts "✅ Health check passed: #{result[:status_code]}"
-          else
-            puts "❌ Health check failed: #{result[:error]}"
-          end
-          
-          result.merge(url: full_url, path: path)
-        rescue URI::InvalidURIError => e
-          {
-            success: false,
-            error: "Invalid URL",
-            details: e.message,
-            url: full_url
-          }
-        end
-      end
-
-      # Perform HTTP request
-      #
-      # @param uri [URI] Target URI
-      # @param timeout [Integer] Timeout in seconds
-      # @return [Hash] Request result
-      def self.perform_request(uri, timeout)
-        start_time = Time.now
-        
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = (uri.scheme == 'https')
-        http.open_timeout = timeout
-        http.read_timeout = timeout
-        
-        request = Net::HTTP::Get.new(uri.request_uri)
-        request['User-Agent'] = 'Clacky-Deploy-Health-Check/1.0'
-        
-        response = http.request(request)
-        elapsed = Time.now - start_time
-
-        {
-          success: response.is_a?(Net::HTTPSuccess),
-          status_code: response.code.to_i,
-          status_message: response.message,
-          elapsed: elapsed.round(2),
-          headers: response.to_hash,
-          body_preview: response.body&.slice(0, 500) # First 500 chars
-        }
-      rescue Net::OpenTimeout, Net::ReadTimeout => e
-        {
-          success: false,
-          error: "Request timeout",
-          details: e.message,
-          elapsed: timeout
-        }
-      rescue SocketError => e
-        {
-          success: false,
-          error: "Network error",
-          details: e.message
-        }
-      rescue StandardError => e
-        {
-          success: false,
-          error: "Health check failed",
-          details: "#{e.class}: #{e.message}"
-        }
-      end
-    end
-  end
-end

data/lib/clacky/default_skills/deploy/tools/create_database_service.rb

@@ -1,341 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "tempfile"
-
-module Clacky
-  module DeployTools
-    # Create a PostgreSQL database service on Railway and wait for it to be ready.
-    #
-    # This tool handles the known Railway CLI bug where `railway add` returns an
-    # error exit code when using project tokens, but actually succeeds in creating
-    # the service.
-    #
-    # Strategy:
-    # 1. Capture existing service IDs before creation
-    # 2. Execute `railway add --database postgres` (ignore exit code)
-    # 3. Poll for new service ID (max 15 seconds)
-    # 4. Wait for DATABASE_URL to be available on the new service (max 2 minutes)
-    #
-    # @example
-    #   result = CreateDatabaseService.execute(
-    #     platform_token: "railway-token-here"
-    #   )
-    #   if result[:success]
-    #     puts "Database created: #{result[:service_name]}"
-    #     puts "DATABASE_URL: #{result[:database_url]}"
-    #   end
-    class CreateDatabaseService
-      
-      # Maximum time to wait for new service to appear after creation command
-      DETECTION_TIMEOUT = 15 # seconds
-      DETECTION_INTERVAL = 3 # seconds
-      
-      # Maximum time to wait for DATABASE_URL to be available
-      PROVISION_TIMEOUT = 120 # seconds (2 minutes)
-      PROVISION_INTERVAL = 5  # seconds
-      
-      # Execute database creation
-      #
-      # @param platform_token [String] RAILWAY_TOKEN for authentication
-      # @return [Hash] {
-      #   success:       Boolean,
-      #   service_id:    String (if success),
-      #   service_name:  String (if success),
-      #   database_url:  String (if success),
-      #   error:         String (if failed)
-      # }
-      def self.execute(platform_token:)
-        new(platform_token).execute
-      end
-      
-      def initialize(platform_token)
-        @platform_token = platform_token
-        @env = { "RAILWAY_TOKEN" => platform_token }
-      end
-      
-      def execute
-        # Step 0: Check if database already exists
-        existing_db = find_existing_database
-        
-        if existing_db
-          puts "  ✅ Database already exists: #{existing_db[:name]}"
-          
-          # Return without DATABASE_URL - Railway automatically shares it across services
-          return {
-            success: true,
-            service_id: existing_db[:id],
-            service_name: existing_db[:name],
-            database_url: nil,  # Don't fetch - Railway auto-injects
-            status: "existing"
-          }
-        end
-        
-        # No database exists - create new one
-        puts "  📦 Creating new PostgreSQL database..."
-        
-        # Step 1: Get existing service IDs
-        existing_service_ids = fetch_service_ids
-        
-        unless existing_service_ids
-          return { success: false, error: "Failed to fetch existing services" }
-        end
-        
-        # Step 2: Execute create command (ignore exit code due to known bug)
-        execute_create_command
-        
-        # Step 3: Detect new service
-        new_service = detect_new_service(existing_service_ids)
-        
-        unless new_service
-          return { success: false, error: "Database service not detected after #{DETECTION_TIMEOUT}s" }
-        end
-        
-        # Step 4: Wait for DATABASE_URL
-        database_url = wait_for_database_url(new_service[:name])
-        
-        unless database_url
-          return {
-            success: false,
-            error: "DATABASE_URL not available after #{PROVISION_TIMEOUT}s for service #{new_service[:name]}"
-          }
-        end
-        
-        {
-          success: true,
-          service_id: new_service[:id],
-          service_name: new_service[:name],
-          database_url: database_url,
-          status: "created"
-        }
-        
-      rescue => e
-        {
-          success: false,
-          error: "Unexpected error: #{e.message}"
-        }
-      end
-      
-      # Find existing Postgres database service
-      # @return [Hash, nil] { id:, name: } or nil if not found
-      private def find_existing_database
-        Tempfile.create('railway_status') do |tmpfile|
-          success = system(
-            @env,
-            "railway", "status", "--json",
-            in: :close,
-            out: tmpfile,
-            err: File::NULL
-          )
-          
-          return nil unless success
-          
-          tmpfile.rewind
-          output = tmpfile.read.strip
-          return nil if output.empty?
-          
-          begin
-            data = JSON.parse(output)
-            
-            # Navigate to production environment's service instances
-            edges = data.dig("environments", "edges")
-            return nil unless edges&.any?
-            
-            prod_env = edges.find { |e| e.dig("node", "name") == "production" }
-            return nil unless prod_env
-            
-            service_edges = prod_env.dig("node", "serviceInstances", "edges")
-            return nil unless service_edges
-            
-            # Find Postgres service (by name pattern or image source)
-            postgres_edge = service_edges.find do |edge|
-              node = edge["node"]
-              next false unless node
-              
-              service_name = node["serviceName"].to_s
-              source_image = node.dig("source", "image").to_s
-              
-              # Match: name contains "Postgres" or "postgres", or source is postgres image
-              service_name.match?(/postgres/i) || source_image.include?("postgres")
-            end
-            
-            return nil unless postgres_edge
-            
-            node = postgres_edge["node"]
-            { id: node["serviceId"], name: node["serviceName"] }
-          rescue JSON::ParserError
-            nil
-          end
-        end
-      end
-      
-      # Fetch all existing service IDs from railway status
-      # @return [Array<String>, nil] Array of service IDs, or nil on failure
-      private def fetch_service_ids
-        Tempfile.create('railway_status') do |tmpfile|
-          success = system(
-            @env,
-            "railway", "status", "--json",
-            in: :close,
-            out: tmpfile,
-            err: File::NULL
-          )
-          
-          return nil unless success
-          
-          tmpfile.rewind
-          output = tmpfile.read.strip
-          return [] if output.empty?
-          
-          begin
-            data = JSON.parse(output)
-            
-            # Extract service IDs from environments.edges[0].node.serviceInstances.edges
-            edges = data.dig("environments", "edges")
-            return [] unless edges&.any?
-            
-            service_instances = edges[0].dig("node", "serviceInstances", "edges")
-            return [] unless service_instances
-            
-            service_instances.map { |edge| edge.dig("node", "serviceId") }.compact
-          rescue JSON::ParserError
-            nil
-          end
-        end
-      end
-      
-      # Execute the railway add command
-      # NOTE: We ignore the exit code because Railway CLI has a known bug
-      # where it returns error with project tokens but still succeeds
-      private def execute_create_command
-        system(
-          @env,
-          "railway", "add", "--database", "postgres",
-          in: :close,
-          out: File::NULL,
-          err: File::NULL
-        )
-        # Exit code intentionally ignored
-      end
-      
-      # Detect newly created service by comparing service IDs
-      # @param existing_ids [Array<String>] Service IDs before creation
-      # @return [Hash, nil] { id: String, name: String } or nil if not found
-      private def detect_new_service(existing_ids)
-        max_attempts = DETECTION_TIMEOUT / DETECTION_INTERVAL
-        
-        max_attempts.times do
-          sleep DETECTION_INTERVAL
-          
-          current_ids = fetch_service_ids
-          next unless current_ids
-          
-          new_ids = current_ids - existing_ids
-          
-          if new_ids.any?
-            # Fetch full service info to get the name
-            return fetch_service_info(new_ids.first)
-          end
-        end
-        
-        nil
-      end
-      
-      # Fetch service name for a given service ID
-      # @param service_id [String]
-      # @return [Hash, nil] { id: String, name: String }
-      private def fetch_service_info(service_id)
-        Tempfile.create('railway_status') do |tmpfile|
-          success = system(
-            @env,
-            "railway", "status", "--json",
-            in: :close,
-            out: tmpfile,
-            err: File::NULL
-          )
-          
-          return nil unless success
-          
-          tmpfile.rewind
-          output = tmpfile.read.strip
-          return nil if output.empty?
-          
-          begin
-            data = JSON.parse(output)
-            edges = data.dig("environments", "edges")
-            return nil unless edges&.any?
-            
-            service_instances = edges[0].dig("node", "serviceInstances", "edges")
-            return nil unless service_instances
-            
-            # Find the service with matching ID
-            service_node = service_instances.find do |edge|
-              edge.dig("node", "serviceId") == service_id
-            end
-            
-            return nil unless service_node
-            
-            {
-              id: service_id,
-              name: service_node.dig("node", "serviceName")
-            }
-          rescue JSON::ParserError
-            nil
-          end
-        end
-      end
-      
-      # Wait for DATABASE_URL to be available on the service
-      # @param service_name [String]
-      # @return [String, nil] DATABASE_URL or nil if timeout
-      private def wait_for_database_url(service_name)
-        max_attempts = PROVISION_TIMEOUT / PROVISION_INTERVAL
-        
-        max_attempts.times do
-          sleep PROVISION_INTERVAL
-          
-          database_url = fetch_database_url(service_name)
-          return database_url if database_url
-        end
-        
-        nil
-      end
-      
-      # Fetch DATABASE_URL from service variables
-      # @param service_name [String]
-      # @return [String, nil] DATABASE_URL value or nil
-      private def fetch_database_url(service_name)
-        tmpfile = Tempfile.new(['railway_vars', '.json'])
-        
-        begin
-          success = system(
-            @env,
-            "railway", "variables", "--service", service_name, "--json",
-            in: :close,
-            out: tmpfile,
-            err: File::NULL
-          )
-          
-          return nil unless success
-          
-          tmpfile.rewind
-          output = tmpfile.read.strip
-          return nil if output.empty?
-          
-          begin
-            # Output should be a JSON hash of variables
-            vars = JSON.parse(output)
-            
-            # Prefer DATABASE_URL, fall back to DATABASE_PUBLIC_URL
-            vars["DATABASE_URL"] || vars["DATABASE_PUBLIC_URL"]
-          rescue JSON::ParserError
-            nil
-          end
-        ensure
-          tmpfile.close
-          tmpfile.unlink
-        end
-      end
-    end
-  end
-end

data/lib/clacky/default_skills/deploy/tools/execute_deployment.rb

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-module Clacky
-  module DeployTools
-    # Trigger a Railway deployment via `railway up` (blocking, with live logs).
-    # Uses RAILWAY_TOKEN passed through environment — no clackycli wrapper needed.
-    class ExecuteDeployment
-
-      # Trigger deployment for a service (blocking - waits for completion).
-      #
-      # @param service_name   [String] Railway service name (from railway.toml or service list)
-      # @param platform_token [String] RAILWAY_TOKEN for this deploy task
-      # @return [Hash] { success: true, url: String } or { success: false, error: String }
-      def self.execute(service_name:, platform_token:)
-        if service_name.nil? || service_name.strip.empty?
-          return { success: false, error: "service_name is required" }
-        end
-
-        if platform_token.nil? || platform_token.strip.empty?
-          return { success: false, error: "platform_token is required" }
-        end
-
-        puts "🚀 Deploying service: #{service_name}"
-        puts "    (This may take several minutes - you'll see live build logs below)"
-        puts ""
-
-        env = { "RAILWAY_TOKEN" => platform_token }
-        
-        # Use railway up without --detach to block and show live logs
-        success = system(
-          env,
-          "railway", "up", "--service", service_name,
-          in: :close  # Don't redirect stdout/stderr - let user see live logs
-        )
-
-        if success
-          puts ""
-          puts "✅ Deployment completed successfully"
-          
-          # Extract URL from railway status after successful deployment
-          url = extract_url(env, service_name)
-          
-          return { success: true, url: url }
-        else
-          puts ""
-          puts "❌ Deployment failed"
-          return { success: false, error: "railway up exited with error code" }
-        end
-
-      rescue => e
-        { success: false, error: "Unexpected error: #{e.message}" }
-      end
-
-      private_class_method def self.extract_url(env, service_name)
-        require "json"
-        require "tempfile"
-        
-        Tempfile.create("railway_status") do |tmpfile|
-          system(
-            env,
-            "railway", "status", "--json",
-            in: :close,
-            out: tmpfile,
-            err: File::NULL
-          )
-          
-          tmpfile.rewind
-          output = tmpfile.read.strip
-          return nil if output.empty?
-          
-          status_data = JSON.parse(output)
-          
-          # Navigate: environments.edges[].node (name="production").serviceInstances.edges[].node
-          env_edges = status_data.dig("environments", "edges")
-          return nil unless env_edges.is_a?(Array)
-          
-          prod_env = env_edges.find { |e| e.dig("node", "name") == "production" }
-          return nil unless prod_env
-          
-          service_edges = prod_env.dig("node", "serviceInstances", "edges")
-          return nil unless service_edges.is_a?(Array)
-          
-          service_edge = service_edges.find do |edge|
-            edge.dig("node", "serviceName") == service_name
-          end
-          return nil unless service_edge
-          
-          domains = service_edge.dig("node", "domains", "customDomains")
-          return nil unless domains.is_a?(Array) && !domains.empty?
-          
-          domain = domains.first["domain"]
-          domain ? "https://#{domain}" : nil
-        end
-      rescue
-        nil
-      end
-    end
-  end
-end

data/lib/clacky/default_skills/deploy/tools/fetch_runtime_logs.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-require "net/http"
-require "uri"
-require "json"
-
-module Clacky
-  module DeployTools
-    # Fetch runtime (environment) logs from a deployed Railway service via
-    # the Clacky Deploy API SSE endpoint.
-    #
-    # Uses DeployApiClient#stream_build_logs for build-phase logs (on failure),
-    # and this class for runtime log fetching (e.g. post-deploy diagnostics).
-    class FetchRuntimeLogs
-      DEFAULT_LINES   = 50
-      MAX_LINES       = 200
-      STREAM_TIMEOUT  = 60   # seconds
-
-      # Fetch recent runtime logs for a project.
-      #
-      # @param project_id     [String]  Clacky project ID
-      # @param workspace_key  [String]  clacky_ak_* key
-      # @param base_url       [String]  API base URL
-      # @param lines          [Integer] max log lines to collect
-      # @param keyword        [String]  optional filter keyword
-      # @return [Hash] { success: true, logs: Array<String> }
-      #             or { success: false, error: String }
-      def self.execute(project_id:, workspace_key:, base_url:,
-                       lines: DEFAULT_LINES, keyword: nil)
-        lines = [[lines.to_i, 1].max, MAX_LINES].min
-
-        params  = "project_id=#{URI.encode_www_form_component(project_id)}"
-        params += "&keyword=#{URI.encode_www_form_component(keyword)}" if keyword
-
-        uri = URI.parse(
-          "#{base_url.to_s.sub(%r{/+$}, "")}" \
-          "/openclacky/v1/deploy/logs/environment/stream?#{params}"
-        )
-
-        collected = []
-
-        http              = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl      = (uri.scheme == "https")
-        http.open_timeout = 10
-        http.read_timeout = STREAM_TIMEOUT
-
-        req                    = Net::HTTP::Get.new(uri.request_uri)
-        req["Authorization"]   = "Bearer #{workspace_key}"
-        req["Accept"]          = "text/event-stream"
-
-        http.request(req) do |response|
-          response.read_body do |chunk|
-            chunk.split("\n").each do |raw|
-              next unless raw.start_with?("data:")
-
-              json_str = raw.sub(/\Adata:\s*/, "")
-              next if json_str.strip.empty?
-
-              begin
-                event = JSON.parse(json_str)
-                msg   = event["message"].to_s
-                collected << msg unless msg.empty?
-                return { success: true, logs: collected } if collected.size >= lines
-              rescue JSON::ParserError
-                # skip malformed events
-              end
-            end
-          end
-        end
-
-        { success: true, logs: collected }
-      rescue => e
-        { success: false, error: "Failed to fetch runtime logs: #{e.message}" }
-      end
-    end
-  end
-end

data/lib/clacky/default_skills/deploy/tools/list_services.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-require "open3"
-require "json"
-
-module Clacky
-  module DeployTools
-    # List Railway services for the linked project.
-    # Uses RAILWAY_TOKEN passed through environment — no clackycli wrapper needed.
-    #
-    # NOTE: In the new deploy flow, service discovery is primarily done via the
-    # Clacky Deploy API (deploy/services endpoint). This tool is kept as a
-    # fallback for detecting the main service name via `railway service list`.
-    class ListServices
-
-      # List services for the current Railway project.
-      #
-      # @param platform_token [String] RAILWAY_TOKEN for this deploy task
-      # @return [Hash] {
-      #   success:      Boolean,
-      #   services:     Array<Hash>,
-      #   main_service: Hash | nil,   # first non-middleware service
-      #   db_service:   Hash | nil    # first postgres/mysql service
-      # }
-      def self.execute(platform_token:)
-        if platform_token.nil? || platform_token.strip.empty?
-          return { success: false, error: "platform_token is required" }
-        end
-
-        env = ENV.to_h.merge("RAILWAY_TOKEN" => platform_token)
-        out, err, status = Open3.capture3(env, "railway status --json")
-
-        unless status.success?
-          return {
-            success: false,
-            error:   "railway service list failed (exit #{status.exitstatus})",
-            details: err
-          }
-        end
-
-        info     = JSON.parse(out)
-        services = info["services"] || []
-
-        main_svc = services.find do |s|
-          name = s["name"].to_s.downcase
-          !%w[postgres postgresql mysql redis].any? { |db| name.include?(db) }
-        end
-
-        db_svc = services.find do |s|
-          name = s["name"].to_s.downcase
-          %w[postgres postgresql mysql].any? { |db| name.include?(db) }
-        end
-
-        {
-          success:      true,
-          services:     services,
-          main_service: main_svc,
-          db_service:   db_svc
-        }
-      rescue JSON::ParserError => e
-        { success: false, error: "Failed to parse service list: #{e.message}", raw: out.to_s[0, 200] }
-      rescue => e
-        { success: false, error: "Unexpected error: #{e.message}" }
-      end
-    end
-  end
-end