kscript 0.1.0

data/lib/kscript/plugins/kk_kibana_utils.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2025 Kk
+#
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+require 'kscript'
+require 'securerandom'
+
+module Kscript
+  class KkKibanaUtils < Base
+    def run
+      with_error_handling do
+        logger.kinfo('Kibana utils executed.')
+      end
+    end
+
+    def initialize(project_name, project_env, base_url, username, password)
+      @base_url = base_url
+      @username = username
+      @password = password
+      @project_name = project_name
+      @project_env = project_env
+      @space_name = "#{project_name}-#{project_env}"
+
+      # Check and create space if it doesn't exist
+      create_space unless space_exists?
+    end
+
+    # Check if the space exists
+    def space_exists?
+      url = "#{@base_url}/api/spaces/space/#{@space_name}"
+      response = client.get(url, headers: kbn_headers)
+      response.status.success?
+    rescue StandardError => e
+      logger.kerror("Error checking space existence: #{e.message}")
+      false
+    end
+
+    # Create a new space
+    def create_space
+      url = "#{@base_url}/api/spaces/space"
+      body = {
+        id: @space_name,
+        name: @space_name,
+        description: "Space for #{@project_name} #{@project_env} environment",
+        color: "##{SecureRandom.hex(3)}", # Random color
+        initials: "#{@project_name[0]}#{@project_env[0]}".upcase
+      }
+
+      response = client.post(url, json: body, headers: kbn_headers)
+      if response.status.success?
+        logger.kinfo("Space '#{@space_name}' created successfully!")
+      else
+        logger.kerror("Failed to create space '#{@space_name}': #{response.body}")
+      end
+    rescue StandardError => e
+      logger.kerror("Error creating space: #{e.message}")
+    end
+
+    # Return the HTTP client with authentication
+    def client
+      @client ||= HTTP.basic_auth(user: @username, pass: @password)
+    end
+
+    # Fetch all indices from Kibana
+    def indices
+      response = client.get("#{@base_url}/api/index_management/indices", headers: kbn_headers)
+      handle_response(response) { |body| JSON.parse(body).map { |item| item['name'] } }
+    end
+
+    # Delete space all index
+    def delete_dataviews
+      url = "#{@base_url}/s/#{@space_name}/api/content_management/rpc/delete"
+      get_dataviews.each do |index|
+        body = {
+          'contentTypeId' => 'index-pattern',
+          'id' => index['id'],
+          'options' => {
+            'force' => true
+          },
+          'version' => 1
+        }
+        client.post(url, json: body, headers: kbn_headers)
+      end
+    end
+
+    # Add a new index to Kibana
+    def add_index(index_name)
+      uuid = SecureRandom.uuid
+      url = "#{@base_url}/s/#{@space_name}/api/content_management/rpc/create"
+      body = index_body(index_name, uuid)
+
+      response = client.post(url, json: body, headers: kbn_headers)
+      if response.status.success?
+        logger.kinfo("#{index_name} Index creation successful!")
+      else
+        handle_error(response, index_name)
+      end
+    end
+
+    # Add all relevant indices to Kibana
+    def add_all_index
+      delete_dataviews
+      indices.each do |index|
+        unless index =~ /#{@project_name}/i && index =~ /#{@project_env}/i && index =~ /#{Time.now.strftime('%Y.%m.%d')}/
+          next
+        end
+
+        add_index(index.gsub(/-\d{4}\.\d{2}\.\d{2}/, ''))
+      end
+    end
+
+    def create_role
+      url = "#{@base_url}/api/security/role/#{@project_name}?createOnly=true"
+      request_body = {
+        'elasticsearch' => {
+          'cluster' => [],
+          'indices' => [
+            {
+              'names' => ["*#{@project_name}*"],
+              'privileges' => ['read']
+            }
+          ],
+          'run_as' => []
+        },
+        'kibana' => [
+          {
+            'spaces' => ["#{@project_name}-prod", "#{@project_name}-uat"],
+            'base' => [],
+            'feature' => {
+              'discover' => ['read']
+            }
+          }
+        ]
+      }.to_json
+      client.put(url, body: request_body, headers: kbn_headers)
+      logger.kinfo("Create #{@project_name} user role sucessed!")
+    end
+
+    def create_user
+      url = "#{@base_url}/internal/security/users/#{@project_name}"
+      request_body = {
+        'password' => '123456',
+        'username' => @project_name,
+        'full_name' => @project_name,
+        'email' => "#{@project_name}@devops.io",
+        'roles' => [@project_name]
+      }.to_json
+      client.post(url, body: request_body, headers: kbn_headers)
+      logger.kinfo("Create #{@project_name} user sucessed!")
+    end
+
+    def self.arguments
+      '[subcommand] [options]'
+    end
+
+    def self.usage
+      "kscript kibana export --host=localhost --index=log-*\nkscript kibana import --file=dashboard.json"
+    end
+
+    def self.group
+      'elastic'
+    end
+
+    def self.author
+      'kk'
+    end
+
+    def self.description
+      'Kibana automation: space, index, user, role management.'
+    end
+
+    private
+
+    # Fetch all index id
+    def get_dataviews
+      url = "#{@base_url}/s/#{@space_name}/api/content_management/rpc/search"
+      # Data payload
+      body = {
+        'contentTypeId' => 'index-pattern',
+        'query' => { 'limit' => 10_000 },
+        'options' => { 'fields' => %w[title type typeMeta name] },
+        'version' => 1
+      }
+      JSON.parse(client.post(url, json: body, headers: kbn_headers))['result']['result']['hits']
+    end
+
+    # Construct the body for creating an index
+    def index_body(index_name, uuid)
+      {
+        "contentTypeId": 'index-pattern',
+        "data": {
+          "fieldAttrs": '{}',
+          "title": "#{index_name}*",
+          "timeFieldName": '@timestamp',
+          "sourceFilters": '[]',
+          "fields": '[]',
+          "fieldFormatMap": '{}',
+          "runtimeFieldMap": '{}',
+          "name": index_name,
+          "allowHidden": false
+        },
+        "options": {
+          "id": uuid,
+          "overwrite": false
+        },
+        "version": 1
+      }
+    end
+
+    # Generate the required headers, including kbn-xsrf
+    def kbn_headers
+      { 'kbn-xsrf' => 'true' }
+    end
+
+    # Handle the response from Kibana
+    def handle_response(response)
+      if response.status.success?
+        yield response.body
+      else
+        handle_error(response)
+      end
+    end
+
+    # Handle errors from Kibana API responses
+    def handle_error(response, index_name = nil)
+      error_message = "Error: #{response.status} - #{response.body}"
+      if index_name
+        logger.kerror("#{index_name} Failed to create index. #{error_message}")
+      else
+        logger.kerror("Error fetching indices: #{error_message}")
+      end
+    end
+  end
+end

data/lib/kscript/plugins/kk_lvm_utils.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2025 Kk
+#
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+require 'kscript'
+
+module Kscript
+  class KkLvmUtils < Base
+    DEFAULT_CONFIG = {
+      device: '/dev/sdb',
+      volume_group: 'vg_data',
+      logical_volume: 'lv_data',
+      mount_point: '/data'
+    }.freeze
+
+    attr_reader :config
+
+    # Initialize the LVM mounter with configuration
+    # @param config [Hash] configuration options
+    def initialize(config = {}, *_args, **_opts)
+      @config = DEFAULT_CONFIG.merge(config)
+    end
+
+    def run
+      with_error_handling do
+        setup
+      end
+    end
+
+    def setup
+      validate_device
+      ensure_lvm_tools_installed
+      setup_physical_volume
+      setup_volume_group
+      setup_logical_volume
+      format_and_mount_volume
+      update_fstab
+      display_mount_status
+    end
+
+    def self.arguments
+      '<device> <mount_point>'
+    end
+
+    def self.usage
+      "kscript lvm /dev/sda2 /mnt/data\nkscript lvm /dev/vg0/lv_home /mnt/home"
+    end
+
+    def self.group
+      'system'
+    end
+
+    def self.author
+      'kk'
+    end
+
+    def self.description
+      'Mount and manage Linux LVM volumes.'
+    end
+
+    private
+
+    # Validate device existence
+    def validate_device
+      return if File.blockdev?(config[:device])
+
+      fail_with_error("Device #{config[:device]} does not exist")
+    end
+
+    # Ensure LVM tools are installed
+    def ensure_lvm_tools_installed
+      return if system('which pvcreate > /dev/null 2>&1')
+
+      logger.kinfo('🔧 Installing LVM tools...')
+      case detect_os_family
+      when 'redhat'
+        run_command('yum install -y lvm2')
+      when 'debian'
+        run_command('apt update && apt install -y lvm2')
+      else
+        fail_with_error('Unsupported OS: cannot install lvm2')
+      end
+    end
+
+    # Set up physical volume
+    def setup_physical_volume
+      return if physical_volume_exists?
+
+      run_command("pvcreate #{config[:device]}")
+    end
+
+    # Set up volume group
+    def setup_volume_group
+      return if volume_group_exists?
+
+      run_command("vgcreate #{config[:volume_group]} #{config[:device]}")
+    end
+
+    # Set up logical volume
+    def setup_logical_volume
+      return if logical_volume_exists?
+
+      run_command("lvcreate -l 100%FREE -n #{config[:logical_volume]} #{config[:volume_group]}")
+    end
+
+    # Format and mount the volume
+    def format_and_mount_volume
+      format_volume unless volume_formatted?
+      mount_volume unless volume_mounted?
+    end
+
+    # Update /etc/fstab for persistent mounting
+    def update_fstab
+      uuid = volume_uuid
+      fstab_line = generate_fstab_entry(uuid)
+
+      return if fstab_contains_uuid?(uuid)
+
+      logger.kinfo('👉 Updating /etc/fstab...')
+      File.open('/etc/fstab', 'a') { |f| f.puts(fstab_line) }
+    end
+
+    # Display current mount status
+    def display_mount_status
+      logger.kinfo("✅ Volume mounted successfully at #{config[:mount_point]}:")
+      system("df -h #{config[:mount_point]}")
+    end
+
+    # Helper methods
+    def detect_os_family
+      content = File.read('/etc/os-release')
+      if content =~ /ID_LIKE=.*rhel|centos|fedora/i || content =~ /ID=.*(rhel|centos|rocky|alma|fedora)/i
+        'redhat'
+      elsif content =~ /ID_LIKE=.*debian/i || content =~ /ID=.*(debian|ubuntu)/i
+        'debian'
+      else
+        'unknown'
+      end
+    end
+
+    def run_command(cmd)
+      logger.kinfo("👉 Running: #{cmd}")
+      system(cmd) || fail_with_error("Command failed: #{cmd}")
+    end
+
+    def fail_with_error(msg)
+      logger.kerror("❌ #{msg}")
+      exit 1
+    end
+
+    def physical_volume_exists?
+      system("pvs #{config[:device]} > /dev/null 2>&1")
+    end
+
+    def volume_group_exists?
+      system("vgs #{config[:volume_group]} > /dev/null 2>&1")
+    end
+
+    def logical_volume_exists?
+      system("lvs /dev/#{config[:volume_group]}/#{config[:logical_volume]} > /dev/null 2>&1")
+    end
+
+    def volume_formatted?
+      `blkid #{logical_volume_path}` =~ /TYPE="xfs"/
+    end
+
+    def volume_mounted?
+      `mount | grep #{config[:mount_point]}`.include?(config[:mount_point])
+    end
+
+    def format_volume
+      run_command("mkfs.xfs #{logical_volume_path}")
+    end
+
+    def mount_volume
+      run_command("mkdir -p #{config[:mount_point]}")
+      run_command("mount #{logical_volume_path} #{config[:mount_point]}")
+    end
+
+    def logical_volume_path
+      "/dev/#{config[:volume_group]}/#{config[:logical_volume]}"
+    end
+
+    def volume_uuid
+      uuid = `blkid #{logical_volume_path} | awk '{print $2}' | tr -d '"'`
+      uuid.strip
+    end
+
+    def fstab_contains_uuid?(uuid)
+      File.read('/etc/fstab').include?(uuid)
+    end
+
+    def generate_fstab_entry(_uuid)
+      "#{logical_volume_path} #{config[:mount_point]} xfs defaults 0 0"
+    end
+  end
+end

data/lib/kscript/plugins/kk_optimize_utils.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2025 Kk
+#
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+require 'kscript'
+require 'open3'
+
+module Kscript
+  class KkOptimizeUtils < Base
+    def run
+      with_error_handling do
+        optimize
+      end
+    end
+
+    def optimize
+      logger.kinfo('🔧 Starting macOS system optimization...')
+
+      # Lower priority for OrbStack Helper
+      orb_pid = `pgrep -f "OrbStack Helper"`.strip
+      unless orb_pid.empty?
+        logger.kinfo("🛑 Found OrbStack Helper (PID: #{orb_pid}), lowering priority...")
+        system("sudo renice +15 #{orb_pid}")
+        logger.kinfo('✅ Priority lowered')
+      end
+
+      # Close background apps
+      apps = ['Telegram', 'Google Chrome']
+      apps.each do |app|
+        if system("pgrep -x \"#{app}\" > /dev/null")
+          logger.kinfo("🛑 Closing #{app}...")
+          system("osascript -e 'tell application \"#{app}\" to quit'")
+        end
+      end
+
+      # Purge memory cache
+      logger.kinfo('🧹 Purging memory cache...')
+      system('sudo purge')
+      logger.kinfo('✅ Memory cache purged')
+
+      # Enable Low Power Mode (macOS 12+)
+      macos_version = `sw_vers -productVersion`.strip
+      if macos_version.split('.').first.to_i >= 12
+        logger.kinfo('⚡ Enabling Low Power Mode...')
+        system('pmset -a lowpowermode 1')
+        logger.kinfo('✅ Low Power Mode enabled')
+      else
+        logger.kwarn("⚠️ Your macOS version (#{macos_version}) does not support Low Power Mode, skipping.")
+      end
+
+      # Show CPU temperature (requires osx-cpu-temp)
+      if system('which osx-cpu-temp > /dev/null')
+        temp = `osx-cpu-temp`.strip
+        logger.kinfo("🌡 Current CPU Temperature: #{temp}")
+      else
+        logger.kinfo("ℹ️ Install 'osx-cpu-temp' to see CPU temperature (brew install osx-cpu-temp)")
+      end
+
+      logger.kinfo('🎉 Optimization complete. Monitor your system for improvements!')
+    end
+
+    def self.arguments
+      '[subcommand] [options]'
+    end
+
+    def self.usage
+      "kscript optimize clean\nkscript optimize speedup"
+    end
+
+    def self.group
+      'macos'
+    end
+
+    def self.author
+      'kk'
+    end
+
+    def self.description
+      'Optimize macOS system performance.'
+    end
+  end
+end

data/lib/kscript/plugins/kk_portscan_utils.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2025 Kk
+#
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+require 'kscript'
+require 'socket'
+require 'timeout'
+
+module Kscript
+  class KkPortscanUtils < Base
+    attr_reader :host, :ports, :thread_count
+
+    # Initialize the scanner with target host and port range
+    # @param host [String] target host to scan
+    # @param ports [Array<Integer>] list of ports to scan
+    # @param thread_count [Integer] number of concurrent threads
+    def initialize(target = nil, ports = (1..1024), *_args, **opts)
+      super(**opts.merge(service: 'kk_port_scanner'))
+      @target = target
+      @ports = ports.is_a?(Range) ? ports : (1..1024)
+    end
+
+    def run
+      with_error_handling do
+        scan
+      end
+    end
+
+    # Execute port scanning using multiple threads
+    def scan
+      msg = "Scanning #{@target} ports #{@ports}"
+      if human_output?
+        puts msg
+      else
+        logger.kinfo(msg)
+      end
+      @ports.each do |port|
+        Socket.tcp(@target, port, connect_timeout: 0.5) do |_sock|
+          if human_output?
+            puts "Port #{port} is open"
+          else
+            logger.kinfo('Port open', port: port)
+            logger.kinfo("Port #{port} is open")
+          end
+        end
+      rescue Errno::ECONNREFUSED, Errno::ETIMEDOUT, SocketError
+        # closed or filtered
+      end
+    end
+
+    def self.description
+      'Scan open ports on a target host.'
+    end
+
+    def self.arguments
+      '<target_host>'
+    end
+
+    def self.usage
+      "kscript portscan 192.168.1.1\nkscript portscan example.com --ports=22,80,443"
+    end
+
+    def self.group
+      'network'
+    end
+
+    def self.author
+      'kk'
+    end
+
+    private
+
+    # Scan a single port for open status
+    # @param port [Integer] port number to scan
+    def scan_port(port)
+      Timeout.timeout(1) do # Set connection timeout to 1 second
+        s = TCPSocket.new(@host, port)
+        logger.kinfo("Port #{port} is open")
+        s.close
+      end
+    rescue Timeout::Error
+      # Connection timeout, ignore
+    rescue StandardError => e
+      logger.kerror("Error scanning port #{port}: #{e.message}")
+    end
+  end
+end

data/lib/kscript/plugins/kk_projscan_utils.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2025 Kk
+#
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+require 'kscript'
+require 'json'
+
+module Kscript
+  class KkProjscanUtils < Base
+    def initialize(src_path = nil, *_args, **opts)
+      super(**opts.merge(service: 'kk_project_scanner'))
+      @src_path = src_path || File.expand_path('~/projects/src')
+    end
+
+    def run
+      with_error_handling do
+        scan_and_display
+      end
+    end
+
+    def scan_and_display
+      ensure_directory_exists
+      projects = scan_projects
+      display_projects(projects)
+    end
+
+    def self.description
+      'Scan and list all git projects in a directory.'
+    end
+
+    def self.arguments
+      '[src_path]'
+    end
+
+    def self.usage
+      "kscript projscan ~/projects/src\nkscript projscan /opt --type=go"
+    end
+
+    def self.group
+      'project'
+    end
+
+    def self.author
+      'kk'
+    end
+
+    private
+
+    def ensure_directory_exists
+      return if Dir.exist?(@src_path)
+
+      logger.kerror("Source directory not found: #{@src_path}")
+      exit 1
+    end
+
+    def scan_projects
+      projects = []
+      Dir.glob(File.join(@src_path, '*')).sort.each do |path|
+        next unless File.directory?(path)
+        next unless git_project?(path)
+
+        project_name = File.basename(path)
+        projects << create_project_entry(project_name, path)
+      end
+      projects
+    end
+
+    def git_project?(path)
+      File.directory?(File.join(path, '.git'))
+    end
+
+    def create_project_entry(name, path)
+      {
+        name: name,
+        rootPath: path,
+        paths: [],
+        tags: [],
+        enabled: true
+      }
+    end
+
+    def display_projects(projects)
+      logger.kinfo('Scanned projects', count: projects.size)
+      logger.kinfo('Projects', projects: JSON.pretty_generate(projects))
+    end
+  end
+end