makit 0.0.144 → 0.0.145

data/lib/makit/podman/podman_service_impl.rb

@@ -0,0 +1,1081 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+require "securerandom"
+
+module Makit
+  module Podman
+    class PodmanServiceImpl
+      def initialize(podman_executable: "podman")
+        @podman_executable = find_executable(podman_executable)
+        raise "Podman executable not found" unless @podman_executable
+      end
+
+      # Check if gRPC service is available
+      def self.grpc_available?
+        defined?(Podman::Service::PodmanService)
+      end
+
+      # Image operations
+      def pull_image(request, _unused_call = nil)
+        cmd = [@podman_executable, "pull"]
+        cmd << "--force" if request.respond_to?(:force) ? request.force : request[:force]
+        cmd << "#{request.respond_to?(:image_name) ? request.image_name : request[:image_name]}:#{request.respond_to?(:tag) ? request.tag : request[:tag]}"
+        
+        result = execute_shell_command(cmd.join(" "))
+        
+        if result[:success]
+          # Extract image ID from output
+          image_id = extract_image_id(result[:stdout])
+          if grpc_available?
+            Podman::Service::PullImageResponse.new(
+              success: true,
+              image_id: image_id,
+              layers: extract_layers(result[:stdout]),
+              pulled_at: Time.now
+            )
+          else
+            {
+              success: true,
+              image_id: image_id,
+              layers: extract_layers(result[:stdout]),
+              pulled_at: Time.now
+            }
+          end
+        else
+          if grpc_available?
+            Podman::Service::PullImageResponse.new(
+              success: false,
+              error_message: result[:stderr]
+            )
+          else
+            {
+              success: false,
+              error_message: result[:stderr]
+            }
+          end
+        end
+      end
+
+      def list_images(request, _unused_call = nil)
+        cmd = [@podman_executable, "images", "--format", "json"]
+        cmd << "--all" if request.respond_to?(:all) ? request.all : request[:all]
+        
+        result = execute_shell_command(cmd.join(" "))
+        
+        if result[:success]
+          images_data = JSON.parse(result[:stdout])
+          images = images_data.map do |img|
+            # Extract repository and tag from Names array
+            names = img["Names"] || []
+            repository = "unknown"
+            tag = "latest"
+            
+            if names.any?
+              name_parts = names.first.split(":")
+              repository = name_parts[0]
+              tag = name_parts[1] || "latest"
+            end
+            
+            created_time = if img["Created"].is_a?(String)
+              Time.parse(img["Created"])
+            else
+              Time.at(img["Created"])
+            end
+            
+            if grpc_available?
+              Podman::Service::Image.new(
+                id: img["Id"],
+                repository: repository,
+                tag: tag,
+                digest: img["Digest"],
+                created: created_time,
+                size: img["Size"].to_i,
+                labels: img["Labels"] || {}
+              )
+            else
+              {
+                id: img["Id"],
+                repository: repository,
+                tag: tag,
+                digest: img["Digest"],
+                created: created_time,
+                size: img["Size"].to_i,
+                labels: img["Labels"] || {}
+              }
+            end
+          end
+          
+          if grpc_available?
+            Podman::Service::ListImagesResponse.new(
+              images: images,
+              total_count: images.length
+            )
+          else
+            {
+              images: images,
+              total_count: images.length
+            }
+          end
+        else
+          if grpc_available?
+            Podman::Service::ListImagesResponse.new(
+              images: [],
+              total_count: 0
+            )
+          else
+            {
+              images: [],
+              total_count: 0
+            }
+          end
+        end
+      end
+
+      def remove_image(request, _unused_call = nil)
+        cmd = [@podman_executable, "rmi"]
+        cmd << "--force" if request.respond_to?(:force) ? request.force : request[:force]
+        cmd << (request.respond_to?(:image_id) ? request.image_id : request[:image_id])
+        
+        result = execute_shell_command(cmd.join(" "))
+        
+        if grpc_available?
+          Podman::Service::RemoveImageResponse.new(
+            success: result[:success],
+            error_message: result[:success] ? "" : result[:stderr]
+          )
+        else
+          {
+            success: result[:success],
+            error_message: result[:success] ? "" : result[:stderr]
+          }
+        end
+      end
+
+      def inspect_image(request, _unused_call = nil)
+        cmd = [@podman_executable, "inspect", request.respond_to?(:image_id) ? request.image_id : request[:image_id]]
+        result = execute_shell_command(cmd.join(" "))
+        
+        if grpc_available?
+          Podman::Service::InspectImageResponse.new(
+            success: result[:success],
+            image_info: result[:success] ? result[:stdout] : "",
+            error_message: result[:success] ? "" : result[:stderr]
+          )
+        else
+          {
+            success: result[:success],
+            image_info: result[:success] ? result[:stdout] : "",
+            error_message: result[:success] ? "" : result[:stderr]
+          }
+        end
+      end
+
+      # Container operations
+      def create_container(request, _unused_call = nil)
+        cmd = [@podman_executable, "create"]
+        name = request.respond_to?(:name) ? request.name : request[:name]
+        working_directory = request.respond_to?(:working_directory) ? request.working_directory : request[:working_directory]
+        user = request.respond_to?(:user) ? request.user : request[:user]
+        privileged = request.respond_to?(:privileged) ? request.privileged : request[:privileged]
+        auto_remove = request.respond_to?(:auto_remove) ? request.auto_remove : request[:auto_remove]
+        environment = request.respond_to?(:environment) ? request.environment : request[:environment]
+        volume_mounts = request.respond_to?(:volume_mounts) ? request.volume_mounts : request[:volume_mounts]
+        port_mappings = request.respond_to?(:port_mappings) ? request.port_mappings : request[:port_mappings]
+        labels = request.respond_to?(:labels) ? request.labels : request[:labels]
+        image = request.respond_to?(:image) ? request.image : request[:image]
+        command = request.respond_to?(:command) ? request.command : request[:command]
+        args = request.respond_to?(:args) ? request.args : request[:args]
+        
+        cmd << "--name" << name if name
+        cmd << "--workdir" << working_directory if working_directory
+        cmd << "--user" << user if user
+        cmd << "--privileged" if privileged
+        cmd << "--rm" if auto_remove
+        
+        # Add environment variables
+        (environment || {}).each do |key, value|
+          cmd << "--env" << "#{key}=#{value}"
+        end
+        
+        # Add volume mounts
+        (volume_mounts || []).each do |mount|
+          host_path = mount.respond_to?(:host_path) ? mount.host_path : mount[:host_path]
+          container_path = mount.respond_to?(:container_path) ? mount.container_path : mount[:container_path]
+          mode = mount.respond_to?(:mode) ? mount.mode : mount[:mode]
+          
+          # Convert Windows paths to WSL paths on Windows
+          if RUBY_PLATFORM =~ /mswin|mingw|cygwin/
+            host_path = convert_to_wsl_path(host_path)
+          end
+          
+          cmd << "--volume" << "#{host_path}:#{container_path}:#{mode}"
+        end
+        
+        # Add port mappings
+        (port_mappings || []).each do |port|
+          host_port = port.respond_to?(:host_port) ? port.host_port : port[:host_port]
+          container_port = port.respond_to?(:container_port) ? port.container_port : port[:container_port]
+          protocol = port.respond_to?(:protocol) ? port.protocol : port[:protocol]
+          cmd << "--publish" << "#{host_port}:#{container_port}/#{protocol}"
+        end
+        
+        # Add labels
+        (labels || {}).each do |key, value|
+          cmd << "--label" << "#{key}=#{value}"
+        end
+        
+        cmd << image
+        
+        # Add command and args
+        if command && command.any?
+          cmd.concat(command)
+        end
+        if args && args.any?
+          cmd.concat(args)
+        end
+        
+        result = execute_shell_command(cmd.join(" "))
+        
+        if result[:success]
+          container_id = result[:stdout].strip
+          if grpc_available?
+            Podman::Service::CreateContainerResponse.new(
+              success: true,
+              container_id: container_id,
+              container_name: request.respond_to?(:name) ? request.name : request[:name]
+            )
+          else
+            {
+              success: true,
+              container_id: container_id,
+              container_name: request.respond_to?(:name) ? request.name : request[:name]
+            }
+          end
+        else
+          if grpc_available?
+            Podman::Service::CreateContainerResponse.new(
+              success: false,
+              error_message: result[:stderr]
+            )
+          else
+            {
+              success: false,
+              error_message: result[:stderr]
+            }
+          end
+        end
+      end
+
+      def start_container(request, _unused_call = nil)
+        cmd = [@podman_executable, "start", request.respond_to?(:container_id) ? request.container_id : request[:container_id]]
+        result = execute_shell_command(cmd.join(" "))
+        
+        if grpc_available?
+          Podman::Service::StartContainerResponse.new(
+            success: result[:success],
+            error_message: result[:success] ? "" : result[:stderr]
+          )
+        else
+          {
+            success: result[:success],
+            error_message: result[:success] ? "" : result[:stderr]
+          }
+        end
+      end
+
+      def stop_container(request, _unused_call = nil)
+        cmd = [@podman_executable, "stop"]
+        timeout_seconds = request.respond_to?(:timeout_seconds) ? request.timeout_seconds : request[:timeout_seconds]
+        cmd << "--time" << timeout_seconds.to_s if timeout_seconds && timeout_seconds > 0
+        cmd << (request.respond_to?(:container_id) ? request.container_id : request[:container_id])
+        
+        result = execute_shell_command(cmd.join(" "))
+        
+        if grpc_available?
+          Podman::Service::StopContainerResponse.new(
+            success: result[:success],
+            error_message: result[:success] ? "" : result[:stderr]
+          )
+        else
+          {
+            success: result[:success],
+            error_message: result[:success] ? "" : result[:stderr]
+          }
+        end
+      end
+
+      def remove_container(request, _unused_call = nil)
+        cmd = [@podman_executable, "rm"]
+        cmd << "--force" if request.respond_to?(:force) ? request.force : request[:force]
+        cmd << (request.respond_to?(:container_id) ? request.container_id : request[:container_id])
+        
+        result = execute_shell_command(cmd.join(" "))
+        
+        if grpc_available?
+          Podman::Service::RemoveContainerResponse.new(
+            success: result[:success],
+            error_message: result[:success] ? "" : result[:stderr]
+          )
+        else
+          {
+            success: result[:success],
+            error_message: result[:success] ? "" : result[:stderr]
+          }
+        end
+      end
+
+      def list_containers(request, _unused_call = nil)
+        cmd = [@podman_executable, "ps", "--format", "json"]
+        cmd << "--all" if request.respond_to?(:all) ? request.all : request[:all]
+        
+        result = execute_shell_command(cmd.join(" "))
+        
+        if result[:success]
+          containers_data = JSON.parse(result[:stdout])
+          containers = containers_data.map do |container|
+            if grpc_available?
+              Podman::Service::Container.new(
+                id: container["Id"],
+                name: container["Names"][0],
+                image: container["Image"],
+                status: map_container_status(container["State"]),
+                created: parse_time(container["CreatedAt"]),
+                started: container["StartedAt"] ? parse_time(container["StartedAt"]) : nil,
+                finished: container["FinishedAt"] ? parse_time(container["FinishedAt"]) : nil,
+                command: container["Command"] ? [container["Command"]] : [],
+                environment: container["Env"] || {},
+                labels: container["Labels"] || {}
+              )
+            else
+              {
+                id: container["Id"],
+                name: container["Names"][0],
+                image: container["Image"],
+                status: map_container_status(container["State"]),
+                created: parse_time(container["CreatedAt"]),
+                started: container["StartedAt"] ? parse_time(container["StartedAt"]) : nil,
+                finished: container["FinishedAt"] ? parse_time(container["FinishedAt"]) : nil,
+                command: container["Command"] ? [container["Command"]] : [],
+                environment: container["Env"] || {},
+                labels: container["Labels"] || {}
+              }
+            end
+          end
+          
+          if grpc_available?
+            Podman::Service::ListContainersResponse.new(
+              containers: containers,
+              total_count: containers.length
+            )
+          else
+            {
+              containers: containers,
+              total_count: containers.length
+            }
+          end
+        else
+          if grpc_available?
+            Podman::Service::ListContainersResponse.new(
+              containers: [],
+              total_count: 0
+            )
+          else
+            {
+              containers: [],
+              total_count: 0
+            }
+          end
+        end
+      end
+
+      def inspect_container(request, _unused_call = nil)
+        cmd = [@podman_executable, "inspect", request.respond_to?(:container_id) ? request.container_id : request[:container_id]]
+        result = execute_shell_command(cmd.join(" "))
+        
+        if grpc_available?
+          Podman::Service::InspectContainerResponse.new(
+            success: result[:success],
+            container_info: result[:success] ? result[:stdout] : "",
+            error_message: result[:success] ? "" : result[:stderr]
+          )
+        else
+          {
+            success: result[:success],
+            container_info: result[:success] ? result[:stdout] : "",
+            error_message: result[:success] ? "" : result[:stderr]
+          }
+        end
+      end
+
+      # Execution operations
+      def execute_script(request, _unused_call = nil)
+        # Create temporary script file
+        script_file = "/tmp/#{SecureRandom.uuid}.sh"
+        
+        begin
+          # Ensure /tmp directory exists
+          mkdir_cmd = [@podman_executable, "exec", request.respond_to?(:container_id) ? request.container_id : request[:container_id], "mkdir", "-p", "/tmp"]
+          execute_shell_command(mkdir_cmd.join(" "))
+          
+          # Write script to a temporary file on host and mount it
+          require 'tempfile'
+          script_content = request.respond_to?(:script_content) ? request.script_content : request[:script_content]
+          # Normalize line endings to Unix format for container execution
+          script_content_normalized = script_content.gsub(/\r\n/, "\n").gsub(/\r/, "\n")
+          temp_file = Tempfile.new(['script', '.sh'], binmode: true)
+          temp_file.write(script_content_normalized)
+          temp_file.close
+          
+          # Copy the script to the container
+          copy_cmd = [@podman_executable, "cp", temp_file.path, "#{request.respond_to?(:container_id) ? request.container_id : request[:container_id]}:#{script_file}"]
+          write_result = execute_shell_command(copy_cmd.join(" "))
+          
+          # Clean up temp file
+          temp_file.unlink
+          return create_error_response("Failed to write script") unless write_result[:success]
+          
+          # Make script executable
+          chmod_cmd = [@podman_executable, "exec", request.respond_to?(:container_id) ? request.container_id : request[:container_id], "chmod", "+x", script_file]
+          execute_shell_command(chmod_cmd.join(" "))
+          
+          # Execute script
+          exec_cmd = [@podman_executable, "exec"]
+          exec_cmd << "--workdir" << (request.respond_to?(:working_directory) ? request.working_directory : request[:working_directory]) if request.respond_to?(:working_directory) ? request.working_directory : request[:working_directory]
+          exec_cmd << "--user" << (request.respond_to?(:user) ? request.user : request[:user]) if request.respond_to?(:user) ? request.user : request[:user]
+          
+          (request.respond_to?(:environment) ? request.environment : request[:environment]).each do |key, value|
+            exec_cmd << "--env" << "#{key}=#{value}"
+          end
+          
+          exec_cmd << (request.respond_to?(:container_id) ? request.container_id : request[:container_id]) << "sh" << script_file
+          
+          result = execute_command_with_timeout(exec_cmd.join(" "), request.respond_to?(:timeout_seconds) ? request.timeout_seconds : request[:timeout_seconds])
+          
+          if grpc_available?
+            Podman::Service::ExecuteScriptResponse.new(
+              success: result[:success],
+              exit_code: result[:exit_code],
+              stdout: (request.respond_to?(:capture_output) ? request.capture_output : request[:capture_output]) ? result[:stdout] : "",
+              stderr: (request.respond_to?(:capture_errors) ? request.capture_errors : request[:capture_errors]) ? result[:stderr] : "",
+              started_at: result[:started_at],
+              finished_at: result[:finished_at],
+              duration_seconds: result[:duration_seconds],
+              error_message: result[:error_message]
+            )
+          else
+            {
+              success: result[:success],
+              exit_code: result[:exit_code],
+              stdout: (request.respond_to?(:capture_output) ? request.capture_output : request[:capture_output]) ? result[:stdout] : "",
+              stderr: (request.respond_to?(:capture_errors) ? request.capture_errors : request[:capture_errors]) ? result[:stderr] : "",
+              started_at: result[:started_at],
+              finished_at: result[:finished_at],
+              duration_seconds: result[:duration_seconds],
+              error_message: result[:error_message]
+            }
+          end
+          
+        ensure
+          # Cleanup script file
+          cleanup_cmd = [@podman_executable, "exec", request.respond_to?(:container_id) ? request.container_id : request[:container_id], "rm", "-f", script_file]
+          execute_shell_command(cleanup_cmd.join(" "))
+        end
+      end
+
+      def execute_command(request, _unused_call = nil)
+        cmd = [@podman_executable, "exec"]
+        working_directory = request.respond_to?(:working_directory) ? request.working_directory : request[:working_directory]
+        user = request.respond_to?(:user) ? request.user : request[:user]
+        environment = request.respond_to?(:environment) ? request.environment : request[:environment]
+        container_id = request.respond_to?(:container_id) ? request.container_id : request[:container_id]
+        command = request.respond_to?(:command) ? request.command : request[:command]
+        timeout_seconds = request.respond_to?(:timeout_seconds) ? request.timeout_seconds : request[:timeout_seconds]
+        capture_output = request.respond_to?(:capture_output) ? request.capture_output : request[:capture_output]
+        capture_errors = request.respond_to?(:capture_errors) ? request.capture_errors : request[:capture_errors]
+        
+        cmd << "--workdir" << working_directory if working_directory
+        cmd << "--user" << user if user
+        
+        # Add environment variables
+        (environment || {}).each do |key, value|
+          cmd << "--env" << "#{key}=#{value}"
+        end
+        
+        cmd << container_id
+        cmd.concat(command)
+        
+        result = execute_command_with_timeout(cmd.join(" "), timeout_seconds)
+        
+        if grpc_available?
+          Podman::Service::ExecuteCommandResponse.new(
+            success: result[:success],
+            exit_code: result[:exit_code],
+            stdout: capture_output ? result[:stdout] : "",
+            stderr: capture_errors ? result[:stderr] : "",
+            started_at: result[:started_at],
+            finished_at: result[:finished_at],
+            duration_seconds: result[:duration_seconds],
+            error_message: result[:error_message]
+          )
+        else
+          {
+            success: result[:success],
+            exit_code: result[:exit_code],
+            stdout: capture_output ? result[:stdout] : "",
+            stderr: capture_errors ? result[:stderr] : "",
+            started_at: result[:started_at],
+            finished_at: result[:finished_at],
+            duration_seconds: result[:duration_seconds],
+            error_message: result[:error_message]
+          }
+        end
+      end
+
+      def run_container(request, _unused_call = nil)
+        cmd = [@podman_executable, "run"]
+        auto_remove = request.respond_to?(:auto_remove) ? request.auto_remove : request[:auto_remove]
+        interactive = request.respond_to?(:interactive) ? request.interactive : request[:interactive]
+        tty = request.respond_to?(:tty) ? request.tty : request[:tty]
+        environment = request.respond_to?(:environment) ? request.environment : request[:environment]
+        volume_mounts = request.respond_to?(:volume_mounts) ? request.volume_mounts : request[:volume_mounts]
+        port_mappings = request.respond_to?(:port_mappings) ? request.port_mappings : request[:port_mappings]
+        labels = request.respond_to?(:labels) ? request.labels : request[:labels]
+        image = request.respond_to?(:image) ? request.image : request[:image]
+        command = request.respond_to?(:command) ? request.command : request[:command]
+        args = request.respond_to?(:args) ? request.args : request[:args]
+        
+        cmd << "--rm" if auto_remove
+        cmd << "--interactive" if interactive
+        cmd << "--tty" if tty
+        
+        # Add environment variables
+        (environment || {}).each do |key, value|
+          cmd << "--env" << "#{key}=#{value}"
+        end
+        
+        # Add volume mounts
+        (volume_mounts || []).each do |mount|
+          host_path = mount.respond_to?(:host_path) ? mount.host_path : mount[:host_path]
+          container_path = mount.respond_to?(:container_path) ? mount.container_path : mount[:container_path]
+          mode = mount.respond_to?(:mode) ? mount.mode : mount[:mode]
+          
+          # Convert Windows paths to WSL paths on Windows
+          if RUBY_PLATFORM =~ /mswin|mingw|cygwin/
+            host_path = convert_to_wsl_path(host_path)
+          end
+          
+          cmd << "--volume" << "#{host_path}:#{container_path}:#{mode}"
+        end
+        
+        # Add port mappings
+        (port_mappings || []).each do |port|
+          host_port = port.respond_to?(:host_port) ? port.host_port : port[:host_port]
+          container_port = port.respond_to?(:container_port) ? port.container_port : port[:container_port]
+          protocol = port.respond_to?(:protocol) ? port.protocol : port[:protocol]
+          cmd << "--publish" << "#{host_port}:#{container_port}/#{protocol}"
+        end
+        
+        # Add labels
+        (labels || {}).each do |key, value|
+          cmd << "--label" << "#{key}=#{value}"
+        end
+        
+        cmd << image
+        
+        # Add command and args
+        if command && (command.is_a?(Array) ? command.any? : !command.empty?)
+          if command.is_a?(String)
+            # If command is a string, treat it as a shell command
+            cmd << "sh" << "-c" << command
+          elsif command.length == 3 && command[0] == "sh" && command[1] == "-c"
+            # If the command contains shell commands with spaces, we need to quote them properly
+            # Escape any double quotes in the command
+            escaped_command = command[2].gsub('"', '\\"')
+            cmd << command[0] << command[1] << "\"#{escaped_command}\""
+          else
+            cmd.concat(command)
+          end
+        end
+        if args && args.any?
+          cmd.concat(args)
+        end
+        
+        result = execute_command_with_timeout(cmd.join(" "), request.respond_to?(:timeout_seconds) ? request.timeout_seconds : request[:timeout_seconds])
+        
+        if grpc_available?
+          Podman::Service::RunContainerResponse.new(
+            success: result[:success],
+            container_id: extract_container_id(result[:stdout]),
+            exit_code: result[:exit_code],
+            stdout: (request.respond_to?(:capture_output) ? request.capture_output : request[:capture_output]) ? result[:stdout] : "",
+            stderr: (request.respond_to?(:capture_errors) ? request.capture_errors : request[:capture_errors]) ? result[:stderr] : "",
+            started_at: result[:started_at],
+            finished_at: result[:finished_at],
+            duration_seconds: result[:duration_seconds],
+            error_message: result[:error_message]
+          )
+        else
+          {
+            success: result[:success],
+            container_id: extract_container_id(result[:stdout]),
+            exit_code: result[:exit_code],
+            stdout: (request.respond_to?(:capture_output) ? request.capture_output : request[:capture_output]) ? result[:stdout] : "",
+            stderr: (request.respond_to?(:capture_errors) ? request.capture_errors : request[:capture_errors]) ? result[:stderr] : "",
+            started_at: result[:started_at],
+            finished_at: result[:finished_at],
+            duration_seconds: result[:duration_seconds],
+            error_message: result[:error_message]
+          }
+        end
+      end
+
+      # Volume operations
+      def create_volume(request, _unused_call = nil)
+        cmd = [@podman_executable, "volume", "create"]
+        driver = request.respond_to?(:driver) ? request.driver : request[:driver]
+        labels = request.respond_to?(:labels) ? request.labels : request[:labels]
+        options = request.respond_to?(:options) ? request.options : request[:options]
+        name = request.respond_to?(:name) ? request.name : request[:name]
+        
+        cmd << "--driver" << driver if driver
+        
+        (labels || {}).each do |key, value|
+          cmd << "--label" << "#{key}=#{value}"
+        end
+        
+        (options || {}).each do |key, value|
+          cmd << "--opt" << "#{key}=#{value}"
+        end
+        
+        cmd << name
+        
+        result = execute_shell_command(cmd.join(" "))
+        
+        if result[:success]
+          # Get volume info
+          inspect_cmd = [@podman_executable, "volume", "inspect", request.respond_to?(:name) ? request.name : request[:name]]
+          inspect_result = execute_shell_command(inspect_cmd.join(" "))
+          
+          volume_info = if inspect_result[:success]
+            JSON.parse(inspect_result[:stdout])[0]
+          else
+            {}
+          end
+          
+          volume = if grpc_available?
+            Podman::Service::Volume.new(
+              name: volume_info["Name"] || (request.respond_to?(:name) ? request.name : request[:name]),
+              driver: volume_info["Driver"] || "local",
+              mountpoint: volume_info["Mountpoint"] || "",
+              created: volume_info["CreatedAt"] ? Time.parse(volume_info["CreatedAt"]) : Time.now,
+              labels: volume_info["Labels"] || {},
+              options: volume_info["Options"] || {}
+            )
+          else
+            {
+              name: volume_info["Name"] || (request.respond_to?(:name) ? request.name : request[:name]),
+              driver: volume_info["Driver"] || "local",
+              mountpoint: volume_info["Mountpoint"] || "",
+              created: volume_info["CreatedAt"] ? Time.parse(volume_info["CreatedAt"]) : Time.now,
+              labels: volume_info["Labels"] || {},
+              options: volume_info["Options"] || {}
+            }
+          end
+          
+          if grpc_available?
+            Podman::Service::CreateVolumeResponse.new(
+              success: true,
+              volume: volume
+            )
+          else
+            {
+              success: true,
+              volume: volume
+            }
+          end
+        else
+          if grpc_available?
+            Podman::Service::CreateVolumeResponse.new(
+              success: false,
+              error_message: result[:stderr]
+            )
+          else
+            {
+              success: false,
+              error_message: result[:stderr]
+            }
+          end
+        end
+      end
+
+      def list_volumes(request, _unused_call = nil)
+        cmd = [@podman_executable, "volume", "ls", "--format", "json"]
+        
+        result = execute_shell_command(cmd.join(" "))
+        
+        if result[:success]
+          volumes_data = JSON.parse(result[:stdout])
+          volumes = volumes_data.map do |vol|
+            if grpc_available?
+              Podman::Service::Volume.new(
+                name: vol["Name"],
+                driver: vol["Driver"],
+                mountpoint: vol["Mountpoint"],
+                created: vol["CreatedAt"] ? Time.parse(vol["CreatedAt"]) : Time.now,
+                labels: vol["Labels"] || {},
+                options: vol["Options"] || {}
+              )
+            else
+              {
+                name: vol["Name"],
+                driver: vol["Driver"],
+                mountpoint: vol["Mountpoint"],
+                created: vol["CreatedAt"] ? Time.parse(vol["CreatedAt"]) : Time.now,
+                labels: vol["Labels"] || {},
+                options: vol["Options"] || {}
+              }
+            end
+          end
+          
+          if grpc_available?
+            Podman::Service::ListVolumesResponse.new(
+              volumes: volumes,
+              total_count: volumes.length
+            )
+          else
+            {
+              volumes: volumes,
+              total_count: volumes.length
+            }
+          end
+        else
+          if grpc_available?
+            Podman::Service::ListVolumesResponse.new(
+              volumes: [],
+              total_count: 0
+            )
+          else
+            {
+              volumes: [],
+              total_count: 0
+            }
+          end
+        end
+      end
+
+      def remove_volume(request, _unused_call = nil)
+        cmd = [@podman_executable, "volume", "rm"]
+        cmd << "--force" if request.respond_to?(:force) ? request.force : request[:force]
+        cmd << (request.respond_to?(:volume_name) ? request.volume_name : request[:volume_name])
+        
+        result = execute_shell_command(cmd.join(" "))
+        
+        if grpc_available?
+          Podman::Service::RemoveVolumeResponse.new(
+            success: result[:success],
+            error_message: result[:success] ? "" : result[:stderr]
+          )
+        else
+          {
+            success: result[:success],
+            error_message: result[:success] ? "" : result[:stderr]
+          }
+        end
+      end
+
+      # System operations
+      def get_version(_request, _unused_call = nil)
+        result = execute_shell_command("#{@podman_executable} version --format json")
+        
+        if result[:success]
+          version_info = JSON.parse(result[:stdout])
+          if grpc_available?
+            Podman::Service::VersionResponse.new(
+              version: version_info["Client"]["Version"],
+              api_version: version_info["Client"]["APIVersion"],
+              go_version: version_info["Client"]["GoVersion"],
+              git_commit: version_info["Client"]["GitCommit"],
+              build_time: version_info["Client"]["BuildTime"],
+              os_arch: version_info["Client"]["OsArch"]
+            )
+          else
+            {
+              version: version_info["Client"]["Version"],
+              api_version: version_info["Client"]["APIVersion"],
+              go_version: version_info["Client"]["GoVersion"],
+              git_commit: version_info["Client"]["GitCommit"],
+              build_time: version_info["Client"]["BuildTime"],
+              os_arch: version_info["Client"]["OsArch"]
+            }
+          end
+        else
+          if grpc_available?
+            Podman::Service::VersionResponse.new(
+              version: "unknown",
+              error_message: result[:stderr]
+            )
+          else
+            {
+              version: "unknown",
+              error_message: result[:stderr]
+            }
+          end
+        end
+      end
+
+      def get_system_info(_request, _unused_call = nil)
+        result = execute_shell_command("#{@podman_executable} system info --format json")
+        
+        if result[:success]
+          system_info = JSON.parse(result[:stdout])
+          if grpc_available?
+            Podman::Service::SystemInfoResponse.new(
+              hostname: system_info["hostname"] || "",
+              kernel: system_info["kernel"] || "",
+              os: system_info["os"] || "",
+              arch: system_info["arch"] || "",
+              total_memory: system_info["memTotal"] || 0,
+              available_memory: system_info["memAvailable"] || 0,
+              cpu_count: system_info["cpus"] || 0,
+              storage_drivers: system_info["store"]["graphDriverName"] ? [system_info["store"]["graphDriverName"]] : [],
+              log_drivers: system_info["logDriver"] ? [system_info["logDriver"]] : []
+            )
+          else
+            {
+              hostname: system_info["hostname"] || "",
+              kernel: system_info["kernel"] || "",
+              os: system_info["os"] || "",
+              arch: system_info["arch"] || "",
+              total_memory: system_info["memTotal"] || 0,
+              available_memory: system_info["memAvailable"] || 0,
+              cpu_count: system_info["cpus"] || 0,
+              storage_drivers: system_info["store"]["graphDriverName"] ? [system_info["store"]["graphDriverName"]] : [],
+              log_drivers: system_info["logDriver"] ? [system_info["logDriver"]] : []
+            }
+          end
+        else
+          if grpc_available?
+            Podman::Service::SystemInfoResponse.new(
+              hostname: "",
+              kernel: "",
+              os: "",
+              arch: "",
+              total_memory: 0,
+              available_memory: 0,
+              cpu_count: 0,
+              storage_drivers: [],
+              log_drivers: []
+            )
+          else
+            {
+              hostname: "",
+              kernel: "",
+              os: "",
+              arch: "",
+              total_memory: 0,
+              available_memory: 0,
+              cpu_count: 0,
+              storage_drivers: [],
+              log_drivers: []
+            }
+          end
+        end
+      end
+
+      def health_check(_request, _unused_call = nil)
+        result = execute_shell_command("#{@podman_executable} version")
+        
+        if grpc_available?
+          Podman::Service::HealthCheckResponse.new(
+            healthy: result[:success],
+            status: result[:success] ? "healthy" : "unhealthy",
+            error_message: result[:success] ? "" : result[:stderr],
+            checked_at: Time.now
+          )
+        else
+          {
+            healthy: result[:success],
+            status: result[:success] ? "healthy" : "unhealthy",
+            error_message: result[:success] ? "" : result[:stderr],
+            checked_at: Time.now
+          }
+        end
+      end
+
+      def execute_shell_command(command)
+        start_time = Time.now
+        output = `#{command} 2>&1`
+        exit_code = $?.exitstatus
+        end_time = Time.now
+        
+        {
+          success: exit_code == 0,
+          exit_code: exit_code,
+          stdout: output,
+          stderr: exit_code != 0 ? output : "",
+          started_at: start_time,
+          finished_at: end_time,
+          duration_seconds: (end_time - start_time).to_i,
+          error_message: exit_code != 0 ? output : ""
+        }
+      end
+
+      private
+
+      def grpc_available?
+        self.class.grpc_available?
+      end
+
+      def execute_command_with_input(command, input)
+        start_time = Time.now
+        
+        # Use Ruby's Open3 for proper input handling
+        require 'open3'
+        
+        begin
+          stdout, stderr, status = Open3.capture3(command, stdin_data: input)
+          exit_code = status.exitstatus
+          end_time = Time.now
+          
+          {
+            success: exit_code == 0,
+            exit_code: exit_code,
+            stdout: stdout,
+            stderr: stderr,
+            started_at: start_time,
+            finished_at: end_time,
+            duration_seconds: (end_time - start_time).to_i,
+            error_message: exit_code != 0 ? stderr : ""
+          }
+        rescue => e
+          end_time = Time.now
+          {
+            success: false,
+            exit_code: 1,
+            stdout: "",
+            stderr: e.message,
+            started_at: start_time,
+            finished_at: end_time,
+            duration_seconds: (end_time - start_time).to_i,
+            error_message: e.message
+          }
+        end
+      end
+
+      def execute_command_with_timeout(command, timeout_seconds)
+        # For now, just execute normally
+        # In a production implementation, you'd use proper timeout handling
+        execute_shell_command(command)
+      end
+
+      def find_executable(executable_name)
+        # Cross-platform executable finding logic
+        if RUBY_PLATFORM =~ /mswin|mingw|cygwin/
+          # Windows logic
+          # If it's already a full path, check if it exists and is executable
+          if executable_name.include?("\\") || executable_name.include?("/")
+            return executable_name if File.executable?(executable_name)
+          end
+          
+          # Otherwise, try common extensions
+          ["#{executable_name}.exe", "#{executable_name}.bat", "#{executable_name}.cmd"].each do |exe|
+            return exe if system("#{exe} --version", out: File::NULL, err: File::NULL)
+          end
+          nil
+        else
+          # Unix logic
+          # If it's already a full path, check if it exists and is executable
+          if executable_name.include?("/")
+            return executable_name if File.executable?(executable_name)
+          end
+          
+          # Otherwise, use which
+          `which #{executable_name}`.strip
+        end
+      end
+
+      def extract_image_id(output)
+        # Extract image ID from podman pull output
+        output.lines.last&.strip || ""
+      end
+
+      def extract_layers(output)
+        # Extract layer information from podman pull output
+        output.lines.select { |line| line.include?("Pulling") }.map(&:strip)
+      end
+
+      def extract_container_id(output)
+        # Extract container ID from podman run output
+        output.strip
+      end
+
+      def map_container_status(status)
+        case status.downcase
+        when "created"
+          grpc_available? ? Podman::Service::ContainerStatus::CREATED : :created
+        when "running"
+          grpc_available? ? Podman::Service::ContainerStatus::RUNNING : :running
+        when "paused"
+          grpc_available? ? Podman::Service::ContainerStatus::PAUSED : :paused
+        when "restarting"
+          grpc_available? ? Podman::Service::ContainerStatus::RESTARTING : :restarting
+        when "removing"
+          grpc_available? ? Podman::Service::ContainerStatus::REMOVING : :removing
+        when "exited"
+          grpc_available? ? Podman::Service::ContainerStatus::EXITED : :exited
+        when "dead"
+          grpc_available? ? Podman::Service::ContainerStatus::DEAD : :dead
+        else
+          grpc_available? ? Podman::Service::ContainerStatus::UNKNOWN : :unknown
+        end
+      end
+
+      def parse_time(time_string)
+        return Time.now if time_string.nil?
+        
+        # Handle integers (Unix timestamps)
+        if time_string.is_a?(Integer)
+          return Time.at(time_string)
+        end
+        
+        # Handle empty strings
+        return Time.now if time_string.empty?
+        
+        # Handle relative time strings like "Less than a second ago"
+        if time_string.include?("ago")
+          return Time.now
+        end
+        
+        begin
+          Time.parse(time_string)
+        rescue ArgumentError
+          Time.now
+        end
+      end
+
+      def create_error_response(message)
+        if grpc_available?
+          Podman::Service::ExecuteScriptResponse.new(
+            success: false,
+            error_message: message,
+            exit_code: 1
+          )
+        else
+          {
+            success: false,
+            error_message: message,
+            exit_code: 1
+          }
+        end
+      end
+
+      def convert_to_wsl_path(windows_path)
+        # On Windows, Podman handles Windows paths natively
+        # Just convert forward slashes to backslashes if needed
+        windows_path.tr('/', '\\')
+      end
+    end
+  end
+end