openclacky 0.9.28 → 0.9.30

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

@@ -1,66 +1,76 @@
 # frozen_string_literal: true
 
+require "net/http"
+require "uri"
+require "json"
+
 module Clacky
   module DeployTools
-    # Fetch runtime logs from deployed service
+    # 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 = 100
-      MAX_LINES = 1000
+      DEFAULT_LINES   = 50
+      MAX_LINES       = 200
+      STREAM_TIMEOUT  = 60   # seconds
 
-      # Fetch runtime logs
+      # Fetch recent runtime logs for a project.
       #
-      # @param service_name [String] Service to fetch logs from
-      # @param lines [Integer] Number of lines to fetch (default: 100)
-      # @return [Hash] Result containing logs
-      def self.execute(service_name:, lines: DEFAULT_LINES)
-        if service_name.nil? || service_name.empty?
-          return {
-            error: "Service name is required",
-            details: "Please provide a valid service name"
-          }
-        end
+      # @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
 
-        # Validate lines parameter
-        lines = lines.to_i
-        if lines <= 0 || lines > MAX_LINES
-          return {
-            error: "Invalid lines parameter",
-            details: "Lines must be between 1 and #{MAX_LINES}",
-            provided: lines
-          }
-        end
+        params  = "project_id=#{URI.encode_www_form_component(project_id)}"
+        params += "&keyword=#{URI.encode_www_form_component(keyword)}" if keyword
 
-        puts "📋 Fetching #{lines} lines of logs for service: #{service_name}"
+        uri = URI.parse(
+          "#{base_url.to_s.sub(%r{/+$}, "")}" \
+          "/openclacky/v1/deploy/logs/environment/stream?#{params}"
+        )
 
-        # Execute command
-        command = "clackycli logs -s #{shell_escape(service_name)} --lines #{lines}"
-        output = `#{command} 2>&1`
-        exit_code = $?.exitstatus
+        collected = []
 
-        if exit_code != 0
-          return {
-            error: "Failed to fetch logs",
-            details: output,
-            exit_code: exit_code,
-            service: service_name
-          }
-        end
+        http              = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl      = (uri.scheme == "https")
+        http.open_timeout = 10
+        http.read_timeout = STREAM_TIMEOUT
 
-        {
-          success: true,
-          service: service_name,
-          lines_requested: lines,
-          logs: output,
-          timestamp: Time.now.iso8601
-        }
-      end
+        req                    = Net::HTTP::Get.new(uri.request_uri)
+        req["Authorization"]   = "Bearer #{workspace_key}"
+        req["Accept"]          = "text/event-stream"
 
-      # Escape shell arguments
-      #
-      # @param str [String] String to escape
-      # @return [String] Escaped string
-      def self.shell_escape(str)
-        "'#{str.gsub("'", "'\\\\''")}'"
+        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

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

@@ -1,79 +1,66 @@
 # frozen_string_literal: true
 
+require "open3"
+require "json"
+
 module Clacky
   module DeployTools
-    # List Railway services with environment variables (sensitive data masked)
+    # 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
-      SENSITIVE_PATTERNS = [
-        /password/i,
-        /secret/i,
-        /api_key/i,
-        /token/i,
-        /credential/i,
-        /private_key/i
-      ].freeze
 
-      # Execute the list_services command
+      # List services for the current Railway project.
       #
-      # @return [Hash] Result containing services array
-      def self.execute
-        output = `clackycli service list --json 2>&1`
-        exit_code = $?.exitstatus
+      # @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")
 
-        if exit_code != 0
+        unless status.success?
           return {
-            error: "Failed to list services",
-            details: output,
-            exit_code: exit_code
+            success: false,
+            error:   "railway service list failed (exit #{status.exitstatus})",
+            details: err
           }
         end
 
-        begin
-          services = JSON.parse(output)
-          masked_services = mask_sensitive_data(services)
-          
-          {
-            success: true,
-            services: masked_services,
-            count: masked_services.length
-          }
-        rescue JSON::ParserError => e
-          {
-            error: "Failed to parse Railway CLI output",
-            details: e.message,
-            raw_output: output
-          }
-        end
-      end
+        info     = JSON.parse(out)
+        services = info["services"] || []
 
-      # Mask sensitive environment variable values
-      #
-      # @param services [Array<Hash>] Array of service objects
-      # @return [Array<Hash>] Services with masked sensitive data
-      def self.mask_sensitive_data(services)
-        services.map do |service|
-          service = service.dup
-          
-          if service['variables']
-            service['variables'] = mask_variables(service['variables'])
-          end
-          
-          service
+        main_svc = services.find do |s|
+          name = s["name"].to_s.downcase
+          !%w[postgres postgresql mysql redis].any? { |db| name.include?(db) }
         end
-      end
 
-      # Mask sensitive variable values
-      #
-      # @param variables [Hash] Environment variables
-      # @return [Hash] Variables with sensitive values masked
-      def self.mask_variables(variables)
-        variables.transform_values do |value|
-          next value unless value.is_a?(String)
-          
-          # Check if variable name matches sensitive patterns
-          is_sensitive = SENSITIVE_PATTERNS.any? { |pattern| value =~ pattern }
-          is_sensitive ? '******' : value
+        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

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

@@ -1,137 +1,188 @@
 # frozen_string_literal: true
 
+require "open3"
+
 module Clacky
   module DeployTools
-    # Set environment variables for a Railway service
+    # Set environment variables on a Railway service via `railway variables --set`.
+    # Uses RAILWAY_TOKEN passed through environment — no clackycli wrapper needed.
+    #
+    # Supports both normal key=value pairs and Railway inter-service references
+    # like ${{postgres.DATABASE_PUBLIC_URL}} (pass raw_value: true to skip escaping).
     class SetDeployVariables
-      PROTECTED_PREFIXES = ['CLACKY_'].freeze
-      
+
       SENSITIVE_PATTERNS = [
-        /password/i,
-        /secret/i,
-        /api_key/i,
-        /token/i,
-        /credential/i,
-        /private_key/i
+        /password/i, /secret/i, /api_key/i,
+        /token/i,    /credential/i, /private_key/i
       ].freeze
 
-      # Execute the set_deploy_variables command
+      # Maximum number of variables to set in a single batch call
+      BATCH_SIZE = 20
+
+      # Retry config for transient failures
+      MAX_RETRIES = 3
+      RETRY_DELAY = 2 # seconds
+
+      # Set one or more environment variables on a Railway service.
+      # Batches all variables into a single `railway variables` call to minimize
+      # network connections and avoid SSL reset issues.
       #
-      # @param service_name [String] Target service name
-      # @param variables [Hash] Simple variables (KEY => VALUE)
-      # @param ref_variables [Hash] Reference variables (KEY => SERVICE.VAR)
-      # @return [Hash] Result of the operation
-      def self.execute(service_name:, variables: {}, ref_variables: {})
-        # Validate service name
-        if service_name.nil? || service_name.empty?
-          return {
-            error: "Service name is required",
-            details: "Please provide a valid service name"
-          }
+      # @param service_name   [String]  Railway service name
+      # @param variables      [Hash]    KEY => VALUE pairs
+      # @param platform_token [String]  RAILWAY_TOKEN for this deploy task
+      # @param raw_value      [Boolean] when true, values are passed unquoted
+      #                                 (for Railway ${{...}} references)
+      # @return [Hash] {
+      #   success:           Boolean,
+      #   set_variables:     Array<String>,
+      #   errors:            Array<Hash>
+      # }
+      def self.execute(service_name:, variables:, platform_token:, raw_value: false)
+        if service_name.nil? || service_name.strip.empty?
+          return { success: false, error: "service_name is required" }
         end
 
-        results = {
-          success: true,
-          service: service_name,
-          set_variables: [],
-          skipped_variables: [],
-          errors: []
-        }
+        env = ENV.to_h.merge("RAILWAY_TOKEN" => platform_token)
 
-        # Set simple variables
+        # Log all variables being set
         variables.each do |key, value|
-          result = set_variable(service_name, key, value, is_reference: false)
-          if result[:success]
-            results[:set_variables] << { key: key, type: 'simple' }
-          elsif result[:skipped]
-            results[:skipped_variables] << { key: key, reason: result[:reason] }
-          else
-            results[:errors] << { key: key, error: result[:error] }
-          end
+          log_value = sensitive?(key) ? "******" : value
+          puts "  Setting #{key}=#{log_value}"
         end
 
-        # Set reference variables
-        ref_variables.each do |key, reference|
-          result = set_variable(service_name, key, reference, is_reference: true)
+        # Split into batches to avoid command line length limits
+        set_vars   = []
+        error_list = []
+        var_pairs  = variables.map { |k, v| [k.to_s, v.to_s] }
+
+        var_pairs.each_slice(BATCH_SIZE) do |batch|
+          result = set_batch(env, service_name, batch, raw_value: raw_value)
           if result[:success]
-            results[:set_variables] << { key: key, type: 'reference' }
-          elsif result[:skipped]
-            results[:skipped_variables] << { key: key, reason: result[:reason] }
+            set_vars.concat(batch.map(&:first))
           else
-            results[:errors] << { key: key, error: result[:error] }
+            # Retry logic: attempt individual vars if batch fails
+            batch.each do |key, value|
+              individual = set_one_with_retry(env, service_name, key, value, raw_value: raw_value)
+              if individual[:success]
+                set_vars << key
+              else
+                error_list << { key: key, error: individual[:error] }
+              end
+            end
           end
         end
 
-        # Overall success if no errors occurred
-        results[:success] = results[:errors].empty?
-        results
+        {
+          success:       error_list.empty?,
+          set_variables: set_vars,
+          errors:        error_list
+        }
       end
 
-      # Set a single environment variable
+      # Set a batch of variables in a single railway command call.
       #
-      # @param service_name [String] Service name
-      # @param key [String] Variable name
-      # @param value [String] Variable value or reference
-      # @param is_reference [Boolean] Whether this is a reference variable
-      # @return [Hash] Result of setting the variable
-      def self.set_variable(service_name, key, value, is_reference:)
-        # Skip protected variables
-        if protected_variable?(key)
-          return {
-            success: false,
-            skipped: true,
-            reason: "Protected system variable (#{key})"
-          }
+      # @param env          [Hash]          environment variables
+      # @param service_name [String]        Railway service name
+      # @param pairs        [Array<Array>]  [[key, value], ...]
+      # @return [Hash] { success: true } or { success: false, error: String }
+      def self.set_batch(env, service_name, pairs, raw_value: false)
+        # Each --set argument is passed as a separate array element
+        set_flags = pairs.flat_map { |key, value| ["--set", "#{key}=#{value}"] }
+        cmd = ["railway", "variables", "--service", service_name, "--skip-deploys"] + set_flags
+
+        # Debug: print the full command being executed
+        puts "  [DEBUG] Executing Railway CLI command:"
+        puts "  [DEBUG] Array form: #{cmd.inspect}"
+        puts "  [DEBUG] Shell form: #{cmd.join(' ')}"
+        puts "  [DEBUG] with RAILWAY_TOKEN=#{env['RAILWAY_TOKEN']}" if env['RAILWAY_TOKEN']
+        $stdout.flush
+
+        # Use system() instead of Open3.capture3 to avoid stdin/stdout blocking issues
+        # system() inherits the current process's stdin/stdout/stderr directly
+        require 'timeout'
+        
+        begin
+          success = Timeout.timeout(30) do
+            # Close stdin, suppress stdout, but keep stderr visible
+            system(env, *cmd, in: :close, out: File::NULL)
+          end
+        rescue Timeout::Error
+          return { success: false, error: "Railway CLI command timed out after 30 seconds" }
         end
 
-        # Build the command
-        if is_reference
-          command = "clackycli variables -s #{shell_escape(service_name)} --set-ref #{shell_escape(key)}=#{shell_escape(value)}"
+        if success
+          { success: true }
         else
-          command = "clackycli variables -s #{shell_escape(service_name)} --set #{shell_escape(key)}=#{shell_escape(value)}"
+          { success: false, error: "railway variables command failed (exit code: #{$?.exitstatus})" }
         end
+      end
 
-        # Log (with sensitive masking)
-        log_value = sensitive_variable?(key) ? '******' : value
-        puts "Setting #{key}=#{log_value} on service #{service_name}"
+      # Set a single variable with retry logic for transient network errors.
+      #
+      # @return [Hash] { success: true } or { success: false, error: String }
+      def self.set_one_with_retry(env, service_name, key, value, raw_value: false)
+        last_error = nil
 
-        # Execute command
-        output = `#{command} 2>&1`
-        exit_code = $?.exitstatus
+        MAX_RETRIES.times do |attempt|
+          result = set_one(env, service_name, key, value, raw_value: raw_value)
+          return result if result[:success]
 
-        if exit_code == 0
-          { success: true }
-        else
-          {
-            success: false,
-            skipped: false,
-            error: output.strip
-          }
+          last_error = result[:error]
+          # Only retry on connection/SSL errors
+          break unless last_error.to_s =~ /connection|ssl|reset|timeout|network/i
+
+          puts "  ⚠️  Retrying #{key} (attempt #{attempt + 2}/#{MAX_RETRIES})..." if attempt < MAX_RETRIES - 1
+          sleep RETRY_DELAY
         end
+
+        { success: false, error: last_error }
       end
 
-      # Check if a variable is protected
+      # Set a single variable. Builds the `railway variables --set` command.
       #
-      # @param key [String] Variable name
-      # @return [Boolean] True if protected
-      def self.protected_variable?(key)
-        PROTECTED_PREFIXES.any? { |prefix| key.start_with?(prefix) }
+      # @return [Hash] { success: true } or { success: false, error: String }
+      def self.set_one(env, service_name, key, value, raw_value: false)
+        assignment = "#{key}=#{value}"
+
+        cmd = [
+          "railway", "variables",
+          "--service", service_name,
+          "--skip-deploys",
+          "--set", assignment
+        ]
+
+        # Debug: print the full command being executed
+        puts "  [DEBUG] Executing single var Railway CLI command:"
+        puts "  [DEBUG] Array form: #{cmd.inspect}"
+        puts "  [DEBUG] Shell form: #{cmd.join(' ')}"
+        puts "  [DEBUG] with RAILWAY_TOKEN=#{env['RAILWAY_TOKEN']}" if env['RAILWAY_TOKEN']
+        $stdout.flush
+
+        # Use system() instead of Open3.capture3 to avoid stdin/stdout blocking issues
+        require 'timeout'
+        
+        begin
+          success = Timeout.timeout(30) do
+            # Close stdin, suppress stdout, but keep stderr visible
+            system(env, *cmd, in: :close, out: File::NULL)
+          end
+        rescue Timeout::Error
+          return { success: false, error: "Railway CLI command timed out after 30 seconds" }
+        end
+
+        if success
+          { success: true }
+        else
+          { success: false, error: "railway variables command failed (exit code: #{$?.exitstatus})" }
+        end
       end
 
-      # Check if a variable is sensitive
-      #
-      # @param key [String] Variable name
-      # @return [Boolean] True if sensitive
-      def self.sensitive_variable?(key)
-        SENSITIVE_PATTERNS.any? { |pattern| key =~ pattern }
+      private_class_method def self.sensitive?(key)
+        SENSITIVE_PATTERNS.any? { |pat| key.match?(pat) }
       end
 
-      # Escape shell arguments
-      #
-      # @param str [String] String to escape
-      # @return [String] Escaped string
-      def self.shell_escape(str)
-        "'#{str.gsub("'", "'\\\\''")}'"
+      private_class_method def self.shell_escape(str)
+        "'#{str.to_s.gsub("'", "'\\\\''")}'"
       end
     end
   end