sensible-cli 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4841010ea567e04f3f358f1f98b9e61aedb419c6f6857f5f2644bc0d9c5d58e3
-  data.tar.gz: 16b5ce3ead9edfd3ff17465f8cb4d5c9463ef5bf14e429e02ab8b70f249921c7
+  metadata.gz: ac1a27c2c7bb7b0b94e321c73538dc2c86acd7fff5a1f08df6c8c8c4457d3312
+  data.tar.gz: 6c09a5676d85d4a19985f9f84a88e9b49f5f00ed760b034f60b7c642a49d47df
 SHA512:
-  metadata.gz: dd36abd65d68819f83f817aa4979bda0ad78aa4b173e42c1792500812ac99501d5d0aaccac02d3d84da2c636338769adc41fcba7453266dbbf1b36efc0763b42
-  data.tar.gz: 5b1e16c926d168f4498e440161c294587428562b1a8672e2bf7606f111219c32e12fd0c5719e96141530698ae9e8c4cd8d3554aca15c65aebf16a6dffa296f90
+  metadata.gz: 471fd3d26546e3c722a550f4f164502ef7ec71a23dada9cb67fd882d8f84388478ed1120f59b3a5ae9f2e543cc7941b39270d2ddba4472e25951f78576ccec2a
+  data.tar.gz: ec7ee80deebbce2917b4f6801e885dd3802f9e90d3e2d1c841ea651b5f34c6f4f48791cd8658f046205a2ddbc8a26d159f4686dd6460cb5e16fb0a9ffe1893f1

data/.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

data/.idea/material_theme_project_new.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="MaterialThemeProjectNewConfig">
+    <option name="metadata">
+      <MTProjectMetadataState>
+        <option name="userId" value="-7c4bb857:19787ef65ab:-7fff" />
+      </MTProjectMetadataState>
+    </option>
+  </component>
+</project>

data/.idea/misc.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="RVM: ruby-3.4.2 [global]" project-jdk-type="RUBY_SDK" />
+</project>

data/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/sensible-ruby.iml" filepath="$PROJECT_DIR$/.idea/sensible-ruby.iml" />
+    </modules>
+  </component>
+</project>

data/.idea/sensible-ruby.iml

@@ -0,0 +1,47 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="RUBY_MODULE" version="4">
+  <component name="ModuleRunConfigurationManager">
+    <shared />
+  </component>
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/features" isTestSource="true" />
+      <sourceFolder url="file://$MODULE_DIR$/spec" isTestSource="true" />
+      <sourceFolder url="file://$MODULE_DIR$/test" isTestSource="true" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" scope="PROVIDED" name="bundler (v2.6.9, RVM: ruby-3.4.2 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="constrain (v0.10.0, RVM: ruby-3.4.2 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="date (v3.4.1, RVM: ruby-3.4.2 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="diff-lcs (v1.6.2, RVM: ruby-3.4.2 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="erb (v5.0.1, RVM: ruby-3.4.2 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="forward_to (v0.3.0, RVM: ruby-3.4.2 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="indented_io (v0.9.0, RVM: ruby-3.4.2 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="io-console (v0.8.0, RVM: ruby-3.4.2 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="irb (v1.15.2, RVM: ruby-3.4.2 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="pastel (v0.8.0, RVM: ruby-3.4.2 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="pp (v0.6.2, RVM: ruby-3.4.2 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="prettyprint (v0.2.0, RVM: ruby-3.4.2 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="psych (v5.2.6, RVM: ruby-3.4.2 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rake (v13.3.0, RVM: ruby-3.4.2 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rdoc (v6.14.0, RVM: ruby-3.4.2 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="reline (v0.6.1, RVM: ruby-3.4.2 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rspec (v3.13.1, RVM: ruby-3.4.2 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rspec-core (v3.13.4, RVM: ruby-3.4.2 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rspec-expectations (v3.13.5, RVM: ruby-3.4.2 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rspec-mocks (v3.13.5, RVM: ruby-3.4.2 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rspec-support (v3.13.4, RVM: ruby-3.4.2 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="shellopts (v2.6.2, RVM: ruby-3.4.2 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="stringio (v3.1.7, RVM: ruby-3.4.2 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="tty-color (v0.6.0, RVM: ruby-3.4.2 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="tty-command (v0.10.1, RVM: ruby-3.4.2 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="tty-cursor (v0.7.1, RVM: ruby-3.4.2 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="tty-prompt (v0.23.1, RVM: ruby-3.4.2 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="tty-reader (v0.9.0, RVM: ruby-3.4.2 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="tty-screen (v0.8.2, RVM: ruby-3.4.2 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="tty-spinner (v0.9.3, RVM: ruby-3.4.2 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="tty-which (v0.5.0, RVM: ruby-3.4.2 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="wisper (v2.0.1, RVM: ruby-3.4.2 [global]) [gem]" level="application" />
+  </component>
+</module>

data/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

data/README.md

@@ -208,3 +208,9 @@ An example of a command that sets the environment to `prod`:
 sensible check --env prod # Check the project for missing dependencies in the prod environment
 sensible install --env stage # Install missing dependencies and requirements in the staging environment
 ```
+
+
+# Todo
+[ ] Add --host support, to run it agains another machine using ssh
+[ ] Variables for tasks
+[ ] Include other tasks?

data/exe/sensible

@@ -1,7 +1,7 @@
-#!/usr/bin/env ruby
+#!/usr/bin/env -S ruby --yjit
 
 SPEC = %(
-  @ A small tool to manage and deploy projects
+  @ A small tool to manage and deploy projects/machines
 
   Install and update systems much like ansible but using shell scripts. It uses
   a sensible.yml configuration file to control the process
@@ -10,14 +10,19 @@ SPEC = %(
     -e,env,environment=ENV
       Sets the environment (dev/prod/etc),
 
-    -f,file=FILE
+    -f,file=CONF:EFILE
       Path to sensible configuration file
 
-    -d,dir,directory=DIR
+    -d,dir,directory=EDIR
       Path to sensible directory. Default '.sensible'
 
+    --host=HOST
+      Run tasks agains a remote machine over ssh. Requires ssh keys added to machine.
+
     -v,verbose
-      Verbose output
+      Verbose
+
+    -a=EFILE
 
   COMMANDS
     check!
@@ -41,17 +46,9 @@ SPEC = %(
 
 require_relative '../lib/sensible.rb'
 require 'shellopts'
+require_relative '../lib/sensible/log'
 
-# Monkey patch where version_number is not fetched correctly in ruby 3.4.2
-module ShellOpts
-  class ShellOpts
-    def version_number
-      Sensible::VERSION
-    end
-  end
-end
-
-opts, args = ShellOpts::process(SPEC, ARGV)
+opts, args = ShellOpts::process(SPEC, ARGV, version_number: Sensible::VERSION)
 cmd = opts.subcommand!
 #cmd == :task! or args.expect(0) # Ensure no arguments except for task
 
@@ -60,31 +57,35 @@ if opts.verbose
   puts "  env: #{opts.env}"
   puts "  file: #{opts.file}"
   puts "  dir: #{opts.dir}"
+  puts "  a: #{opts.a}"
   puts "  args: #{args}"
-  # puts "Command: #{cmd.to_s.sub(/!$/, "")}"
 end
 
+if opts.subcommand == :init!
+  Sensible::Sensible.init(opts)
+  exit
+end 
+
+sensible = Sensible::Sensible.new("sensible.yml", opts, args)
 case opts.subcommand
-  when :init!
-    Sensible::Sensible.init(opts)
-  else
-    sensible = Sensible::Sensible.new("sensible.yml", opts, args)
-
-    case opts.subcommand
-      when :check!
-        sensible.check
-      when :install!
-        sensible.install
-      when :task!
-        case cmd.subcommand
-          when :list!; sensible.task_list
-          when :run!
-            arg = args.expect(1) # Expect a single argument to sensible task
-            sensible.task_run(arg)
-          when :create!
-            arg = args.expect(1) # Expect a single argument to sensible task
-            sensible.task_create(arg)
-        end
+  when :check!
+    sensible.check
+  when :install!
+    sensible.install
+  when :task!
+    case opts.subcommand!.subcommand
+      when nil
+        Sensible::Logger::error "Missing subcommand"
+      when :list!; sensible.task_list
+      when :run!
+        arg = args.expect(1) # Expect a single argument to sensible task
+        sensible.task_run(arg)
+      when :create!
+        arg = args.expect(1) # Expect a single argument to sensible task
+        sensible.task_create(arg)
     end
+  else
+    ShellOpts::error "Missing command"
 end
 
+

data/lib/sensible/log.rb

@@ -7,7 +7,14 @@ module Sensible
 
   class Logger 
     def self.log(message, indent = 0, use_print: false)
-        puts message
+      spaceIndent = ""
+      indent.times { |i| spaceIndent << " " }
+
+      if use_print
+        print "#{spaceIndent}#{message}"
+      else      
+        puts "#{spaceIndent}#{message}"
+      end
     end
 
     def self.success(message, indent = 0, use_print: false)
@@ -64,5 +71,13 @@ module Sensible
 
       prompt.yes?("#{spaceIndent}#{message}")
     end
+
+    def self.clear_line()
+      print "\r\e[K"
+    end
+
+    def self.flush
+      $stdout.flush
+    end
   end
 end

data/lib/sensible/package.rb

@@ -1,4 +1,5 @@
 require_relative 'log'
+require_relative 'shell'
 require 'tty-prompt'
 require 'pastel'
 
@@ -6,47 +7,57 @@ module Sensible
   class Package
     attr_reader :sensible
     attr_reader :name
-    attr_reader :check
-    attr_reader :install
-    attr_reader :env
-
-    def initialize(packageHash, sensible)
-      @name = packageHash['name']
-      @check = packageHash['check']
-      @install = packageHash['install']
-      @env = packageHash['env'] || []
+    attr_reader :distro
 
+    def initialize(packageName, distro, sensible)
+      @name = packageName
+      @distro = distro
       @sensible = sensible
     end
 
-
     # Check if the package is installed
     def do_check
-      if @check
-        result = `#{@check}`
-        return $?.success?
-      else 
-        # If check is not set, then infer that it's a system package
-        result = `rpm -q #{@name}`
+      check_command = nil
+
+      case @distro
+        when "rpm"
+          check_command = "rpm -q #{name}"
+        when "deb"
+          check_command = "dpkg-query -W #{name}"
+        when "aur"
+          check_command = "pacman -Qi #{name}"
+      end
       
-        if result.include? 'is not installed'
-          return false
-        else 
-          return true
-        end
+      if check_command == nil
+        Logger.error("Unknown check command")
+        exit(1)
       end
-                 
+
+      # Run the shell command
+      shell = Shell.new(@sensible)
+      return shell.run_command(check_command)        
     end
     
     # Install the package
     def do_install
-      if @install 
-        system(@install, out: File::NULL)
-        return $?.success?        
-      else
-        system("sudo", "dnf", "install", "-y", @name, out: File::NULL, err: File::NULL)
-        return $?.success?
+      install_command = nil
+
+      case @distro
+      when "rpm"
+        install_command = "sudo dnf install -y #{name}"
+      when "deb"
+        install_command = "sudo apt get install -y #{name}"
+      when "aur"
+        install_command = "pacman -Syu #{name}"
+      end
+
+      if install_command == nil
+        Logger.error("Unknown install command")
+        exit(1)
       end
-    end   
+
+      shell = Shell.new(@sensible)
+      return shell.run_command(install_command)  
+    end 
   end
 end

data/lib/sensible/parse.rb

@@ -5,7 +5,7 @@ require_relative 'package'
 module Sensible
   class Parse
     
-    # Parse the package list from sensible.yml
+    # Parse the package list
     def self.parse_sensible_packages(sensible_hash_list, sensible)
       list = []
       for pkg in sensible_hash_list

data/lib/sensible/requirement.rb

@@ -1,7 +1,77 @@
 require_relative 'package'
+require_relative 'parse'
 
 module Sensible
-  class Requirement < Package
+  class Requirement
+    attr_reader :sensible
+    attr_reader :name
+    attr_reader :check
+    attr_reader :install
+    attr_reader :env
+    attr_reader :description
+    attr_reader :packages
     # Pretty much the same as package right now
+
+    def initialize(requirement_file_name, sensible)
+      requirement_file_path = "#{sensible.sensible_folder}/#{sensible.requirements_folder}/#{requirement_file_name}.yml"
+
+      # If requirement is not found, exit!
+      if not File.exist?(requirement_file_path)
+        pastel = Pastel.new
+        Logger.error("Requirement: #{pastel.bold(requirement_file_name)} does not exist!")
+        exit(1)
+      end
+
+      # Load the data
+      requirement_data = YAML.load_file(requirement_file_path)
+
+      @sensible = sensible
+      @name = requirement_data["name"]
+      @check = requirement_data["check"]
+      @install = requirement_data["install"]
+      @env = requirement_data["env"]
+      @description = requirement_data["description"]
+
+      # Parse packages
+      @packages = Parse::parse_sensible_packages(requirement_data['packages'], sensible)
+    end
+
+    def do_check
+      # If check is not set, always run the task
+      if @check == nil
+        return false
+      end
+
+      # If there is no check, default to false, to force task to install every time
+      system(@check, out: File::NULL)
+      return $?.success?
+    end  
+
+    def do_install
+      # TODO: Handle the show output property!
+
+      if @install.include?("\n")
+        temp_path = "/tmp/sensible"
+        temp_file_name = "install.sh"
+        temp_file_path = "#{temp_path}/#{temp_file_name}"
+
+        # Make sure we have the tmp folder created
+        FileUtils.mkdir_p(temp_path)
+
+        File.open(temp_file_path, "w") do |f| 
+          f.puts "#!/usr/bin/env bash\n\n"
+          f.write(@install)
+        end
+
+        # Make it executable
+        File.chmod(0700, temp_file_path)
+
+        system("#{temp_file_path}", out: File::NULL, err: File::NULL)
+        return $?.success?  
+      else
+        system(@install, out: File::NULL, err: File::NULL)
+        return $?.success?        
+      end
+    end
   end
 end

data/lib/sensible/shell.rb

@@ -0,0 +1,106 @@
+require 'net/ssh'
+
+module Sensible
+  class Shell
+    attr_reader :sensible
+
+    def initialize(sensible)
+      @sensible = sensible
+    end
+
+    def run_command(command, user = nil, show_output: false)
+      show_output = @sensible.opts.verbose
+
+      if (@sensible.opts.host != nil)
+        # Run command on remote machine
+        Net::SSH.start(@sensible.opts.host, 'root') do |ssh| 
+          out, err, code = exec_user_with_status(ssh, command, as_user: user)
+          
+          if @sensible.opts.verbose
+            puts "STDOUT: #{out}"
+            puts "STDERR: #{err}"
+            puts "EXIT CODE: #{code}"
+          end
+          
+          # Show a warning if the user does not exist!
+          if err.include?("does not exist or the user entry does not contain all the required fields")
+            Logger.error("User: '#{user}' does not exist!")
+          end
+
+
+          if code == 0
+            return true
+          else 
+            return false
+          end
+        end
+      else
+        # Standard local shell command
+        # If command contains new lines, use a temporary file
+        if command.include?("\n")
+          system("bash", "-c", command, out: (show_output ? $stdout : File::NULL), err: (show_output ? $stderr : File::NULL))
+          return $?.success?
+        else
+          if user != nil
+            system("sudo -u #{user} #{command}", out: (show_output ? $stdout : File::NULL), err: (show_output ? $stderr : File::NULL))
+          else 
+            system(command, out: (show_output ? $stdout : File::NULL), err: (show_output ? $stderr : File::NULL))
+          end
+          return $?.success?    
+        end
+      end
+    end
+
+    def exec_with_status(ssh, command)
+      stdout = stderr = ""
+      exit_code = nil
+
+      ssh.open_channel do |ch|
+        ch.exec(command) do |ch, success|
+          raise "could not exec #{command}" unless success
+
+          ch.on_data          { |c, d| stdout << d }
+          ch.on_extended_data { |c, t, d| stderr << d }
+          ch.on_request("exit-status") { |c, data| exit_code = data.read_long }
+        end
+      end
+      ssh.loop
+      [stdout, stderr, exit_code]
+    end
+
+    def exec_user_with_status(ssh, command, as_user: nil)
+      stdout    = ''
+      stderr    = ''
+      exit_code = nil
+
+      ssh.open_channel do |ch|
+
+        if as_user 
+          ch.exec("su - #{as_user}") do |ch_exec, success|
+            raise "could not exec sudo" unless success
+            ch.send_data("#{command}\n")
+
+            ch.on_data          { |_, data| stdout << data }
+            ch.on_extended_data { |_, _, data| stderr << data }
+            ch.on_request("exit-status") { |_, data| exit_code = data.read_long }
+
+            # when done:
+            ch.send_data("exit\n")
+          end
+        else
+          ch.exec(command) do |ch_exec, success|
+            raise "Could not exec #{cmd}" unless success
+
+            ch.on_data          { |_, data| stdout << data }
+            ch.on_extended_data { |_, _, data| stderr << data }
+            ch.on_request("exit-status") { |_, data| exit_code = data.read_long }
+          end
+        end
+      end
+
+      ssh.loop
+      [stdout, stderr, exit_code]
+    end
+
+  end
+end

data/lib/sensible/task.rb

@@ -1,66 +1,98 @@
 require_relative 'package'
+require_relative 'shell'
 
 module Sensible
-  class Task < Package
+  class Task
+    attr_reader :sensible
+    attr_reader :name
+    attr_reader :packages
+    attr_reader :check
+    attr_reader :script
+    attr_reader :require
+    attr_reader :env
     attr_reader :file_name
+    attr_reader :user
     attr_reader :description
     attr_accessor :show_output
 
-    def initialize(taskHash, file_name, sensible)
-      super(taskHash, sensible)
+    def initialize(taskHash, file_name, user = nil, sensible)
+      @name = taskHash['name']
+      @check = taskHash['check']
+      @script = taskHash['script']
+      @require = taskHash['require']
+      @env = taskHash['env'] || []
       @file_name = file_name
       @description = taskHash['description']
       @show_output = taskHash['showOutput']
-    end
-    
-    def do_check
-      do_verify()
-
-      # If check is not set, always run the task
-      if @check == nil
-        return false
+      
+      # If task is initalized with user, force use of that
+      if user != nil
+        @user = user
+      end
+      
+      # Always use the user from the task
+      if taskHash['user'] != nil
+        @user = taskHash['user']
       end
 
-      # If there is no check, default to false, to force task to install every time
-      system(@check, out: File::NULL)
-      return $?.success?
-    end  
-
-    def do_install
-      # TODO: Handle the show output property!
+      @sensible = sensible
+      
+      @packages = []
+      if taskHash['packages']
+        taskHash['packages'].each do |distro, packages|
+          packages.each do |packageName|
+            @packages << Package.new(packageName, distro, sensible)
+          end
+        end
+      end
+    end
 
-      if @install.include?("\n")
-        temp_path = "/tmp/sensible"
-        temp_file_name = "install.sh"
-        temp_file_path = "#{temp_path}/#{temp_file_name}"
+    # Check if the packages in this task is installed
+    def do_packages_check
+      has_all_packages_install = true
 
-        # Make sure we have the tmp folder created
-        FileUtils.mkdir_p(temp_path)
+      @packages.each do |package|
+        package.name
 
-        File.open(temp_file_path, "w") do |f| 
-          f.puts "#!/usr/bin/env bash\n\n"
-          f.write(@install)
+        if !package.do_check
+          has_all_packages_install = false
         end
+      end
+      
+      return has_all_packages_install
+    end
 
-        # Make it executable
-        File.chmod(0700, temp_file_path)
+    # Install the packages in this task
+    def do_packages_install
+      has_all_packages_install = true
 
-        system("#{temp_file_path}", out: File::NULL)
-        return $?.success?  
-      else
-        system(@install, out: File::NULL)
-        return $?.success?        
+      @packages.each do |package|
+        if !package.do_install
+          has_all_packages_install = false
+        end
       end
-    end
 
-    def do_verify
-      if !@install
-        pastel = Pastel.new
-        Logger.error("This is not valid task, #{pastel.bold("install")} property is missing!")
-        exit(1)
+      return has_all_packages_install
+    end
+    
+    def do_check
+      # If check is not set, always run the task
+      if @check == nil
         return false
       end
 
+      # If there is no check, default to false, to force task to script every time
+      shell = Shell.new(@sensible)
+      return shell.run_command(@check, @user)
+    end
+
+    def do_script
+      # TODO: Handle the show output property!
+      shell = Shell.new(@sensible)
+      return shell.run_command(@script, @user)         
+    end
+
+    def do_verify
       return true
     end
   end

data/lib/sensible/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Sensible
-  VERSION = "0.1.0"
+  VERSION = "0.2.1"
 end

data/lib/sensible.rb

@@ -12,21 +12,13 @@ module Sensible
     attr_reader :opts
     attr_reader :args
 
-    attr_reader :preTasks
-    attr_reader :packages
-    attr_reader :requirements
-    attr_reader :postTasks
-    
-    attr_reader :sensible_folder
-    attr_reader :tasks_folder
+    attr_reader :tasks
 
 
     def initialize(sensibleFileName, opts, args)
       @opts = opts
       @args = args
 
-      @sensible_folder = '.sensible'
-      @tasks_folder = 'tasks'
 
       file_name = opts.file || sensibleFileName
       unless File.exist?(file_name)
@@ -37,66 +29,85 @@ module Sensible
       # Load the Sensile file
       sensible_file_data = YAML.load_file(file_name)
 
-      # Parse packages
-      if sensible_file_data['packages'] 
-        @packages = Parse.parse_sensible_packages(sensible_file_data['packages'], self)
-      end
 
-      # Parse packages
-      if sensible_file_data['requirements'] 
-        @requirements = Parse.parse_sensible_requirements(sensible_file_data['requirements'], self)
-      end
+      # Recursively go through all the tasks inside the sensible file
+      # Add them to a list, that we will go through later
+      @tasks = []
+      def process_task(task_line, task_user = nil)
+        task = nil
+        
+        # Handle inline tasks inside root sensible file
+        if task_line.class == Hash
+          task = Task.new(task_line, task_line, task_user, self)
+        end
 
-      if (sensible_file_data['preTasks'])
-        @preTasks = sensible_file_data['preTasks']
-      end
+        if task_line.is_a?(String)
+          task_yaml = YAML.load_file(task_line + '.yml')
+          task = Task.new(task_yaml, task_line, task_user, self)
+        end
 
-      if (sensible_file_data['postTasks'])
-        @postTasks = sensible_file_data['postTasks']
+        if task.require != nil
+          task.require.each do |path|
+            process_task(path, task.user)
+          end
+        end
+
+        @tasks << task
+      end 
+
+      sensible_file_data.each do |key, value|
+        case key
+          when "require"
+            value.each do |path|
+              process_task(path)
+            end
+          when "tasks"
+            value.each do |path|
+              process_task(path)
+            end
+        end 
       end
     end
 
 
     # Run all the checks for packages and requirements
     def check
-      Logger.log("Checking for installed packages...")
+      # Prewarm sudo, to prevent asking too much
+      shell = Shell.new(self)
+      shell.run_command('sudo -v', show_output: true)
       
-      for pkg in @packages
-        # Do an environment test
-        if @opts.env
-          # If package env is not define, we expect it should always be installed regardless of environment
-          # If user has defined an environment, skip if the set environment isn't in the package enviroment list 
-          next if pkg.env.any? && !pkg.env.include?(@opts.env)
-        else
-          # If env contains anything, when env is not defined in opts, skip it, as this is not the correct env
-          next if pkg.env.any?
+      @tasks.each_with_index do |task, index|
+        user = nil
+        if task.user
+          user = "(User: #{task.user})"
         end
 
-        if pkg.do_check
-          Logger.success("#{pkg.name} is installed")
+        pastel = Pastel.new
+        if index > 0
+          Logger.log("\n#{pastel.bold(task.name)} #{user}")
         else
-          Logger.danger("#{pkg.name} was NOT installed")
+          Logger.log("#{pastel.bold(task.name)} #{user}")
         end
-      end    
-      
-      if @requirements != nil
-        Logger.log("\nChecking if requirements are met...")
-
-        for requirement in @requirements
-          # Do an environment test
-          if @opts.env
-            # If package env is not define, we expect it should always be installed regardless of environment
-            # If user has defined an environment, skip if the set environment isn't in the package enviroment list 
-            next if requirement.env.any? && !requirement.env.include?(@opts.env)
+
+        # Do an environment test
+        # if @opts.env
+        #   # If requirement env is not define, we expect it should always be installed regardless of environment
+        #   # If user has defined an environment, skip if the set environment isn't in the package enviroment list 
+        #   next if requirement.env.any? && !requirement.env.include?(@opts.env)
+        # end
+        if task.packages.length > 0
+          if task.do_packages_check
+            Logger.success("Packages installed!")
           else
-            # If env contains anything, when env is not defined in opts, skip it, as this is not the correct env
-            next if pkg.env.any?
+            Logger.danger("Packages NOT installed!")
           end
+        end
 
-          if requirement.do_check
-            Logger.success("#{requirement.name}")
+        if task.check
+          if task.do_check
+            Logger.success("Is installed!")
           else
-            Logger.danger("#{requirement.name}")
+            Logger.danger("Is NOT installed!")
           end
         end
       end
@@ -104,85 +115,66 @@ module Sensible
 
     def install
       # Prewarm sudo, to prevent asking too much
-      system('sudo -v')
+      shell = Shell.new(self)
+      shell.run_command('sudo -v', show_output: true)
 
-      # Run pre tasks
-      if @preTasks != nil
-        Logger.log("Running pre tasks...")
+      
+      @tasks.each_with_index do |task, index|
+        user = nil
+        if task.user
+          user = "(#{task.user})"
+        end
 
-        for task in @preTasks
-          task_run(task)
+        pastel = Pastel.new
+        if index > 0
+          Logger.log("\n#{pastel.bold(task.name)} #{user}")
+        else
+          Logger.log("#{pastel.bold(task.name)} #{user}")
         end
-        Logger.log("")
-      end
-      
-      # Install packages
-      if @packages != nil
-        Logger.log("Installing packages...")
-        for pkg in @packages
-          # Do an environment test
-          if @opts.env
-            # If package env is not defined, we expect it should always be installed regardless of environment
-            # If user has defined an environment, skip if the set environment isn't in the package enviroment list 
-            next if pkg.env.any? && !pkg.env.include?(@opts.env)
-          else
-            # If env contains anything, when env is not defined in opts, skip it, as this is not the correct env
-            next if pkg.env.any?
-          end
 
-          if pkg.do_check
-            Logger.success("#{pkg.name} is installed")
+
+        # Do an environment test
+        # if @opts.env
+        #   # If requirement env is not define, we expect it should always be installed regardless of environment
+        #   # If user has defined an environment, skip if the set environment isn't in the package enviroment list
+        #   next if requirement.env.any? && !requirement.env.include?(@opts.env)
+        # end
+        if task.packages.length > 0
+          if task.do_packages_check
+            Logger.success("Packages installed!")
           else
-            Logger.info("Installing: #{pkg.name}\r", use_print: true)
-            if pkg.do_install
-              Logger.success("#{pkg.name} was installed")
-              $stdout.flush
+            Logger.info("Installing packages...\r", use_print: true)
+            if task.do_packages_install
+              Logger.clear_line
+              Logger.success("Packages installed!")
             else
-              Logger.danger("#{pkg.name} was not installed")
-              $stdout.flush
+              Logger.clear_line
+              Logger.danger("Packages NOT installed!")
             end
+
+            Logger.flush
           end
-        end  
-        Logger.log("")
-      end
-      
-      # Handle requirements
-      if @requirements != nil 
-        Logger.log("Handling requirements...")
-        for requirement in @requirements
-          # Do an environment test
-          if @opts.env
-            # If package env is not defined, we expect it should always be installed regardless of environment
-            # If user has defined an environment, skip if the set environment isn't in the package enviroment list 
-            next if requirement.env.any? && !requirement.env.include?(@opts.env)
-          else
-            # If env contains anything, when env is not defined in opts, skip it, as this is not the correct env
-            next if requirement.env.any?
-          end
+        end
 
-          if requirement.do_check
-            Logger.success("#{requirement.name}")
+        if task.check
+          if task.do_check
+            Logger.success("Is installed!")
           else
-            Logger.info("Handling: #{pkg.name}\r", use_print: true)
-            if requirement.do_install
-              Logger.success("#{requirement.name}")
-              $stdout.flush
+            if task.script
+              Logger.info("Running task...\r", use_print: true)
+              if task.do_script
+                Logger.clear_line
+                Logger.success("Is installed!")
+              else
+                Logger.clear_line
+                Logger.danger("Is NOT installed!")
+              end
+              Logger.flush
             else
-              Logger.danger("#{requirement.name}")
-              $stdout.flush
+              Logger.danger("Is NOT installed!")
             end
           end
         end
-        Logger.log("")
-      end
-    
-      # Run post tasks
-      if @postTasks != nil
-        Logger.log("Running post tasks...")
-
-        for task in @postTasks
-          task_run(task)
-        end
       end
 
     end

data/new-sensible-spec.md

@@ -0,0 +1,140 @@
+# New sensible specification
+
+To structure everything better, and making it efficient for setting up machines or projects, i've come up with a new specification.
+
+You are now able to completely able to define your own structure,
+
+sensible.yml inside a project for folder:
+
+```yaml
+packages:
+  - rpm: [btop]
+
+require: 
+  - .sensible/requirements/postgres17 # Path to the task
+  - .sensible/requirements/httpd
+
+tasks:
+  - .sensible/tasks/test
+
+options: 
+  # Possible future options
+```
+
+The nice thing here is, that the order of where you place the packages, require and tasks property matters. It parses the file from top-to-bottom, so in this example, it install packages first, handle requirements, and run tasks at the end. You could do it in complete reverse order if you wanted.
+
+The same thing with the require and tasks property, the list in there, will be handled in that order..
+
+When you add an requirement, it's the relative path from where you execute sensible from.
+
+## Folder structure example
+
+```
+.sensible/
+  requirements/
+    httpd.yml
+    postgresql17.yml
+  tasks/
+    another.yml
+    test.yml
+sensible.yml
+```
+
+You could also structure it like this:
+
+```
+services/
+  httpd.yml
+  postgresql17.yml
+tasks/
+  another.yml
+  test.yml
+hosts/
+  server1.yml
+  server2.yml
+```
+
+Then you run the command: `sensible -f check hosts/server1.yml` or `sensible -f install hosts/server1.yml`
+
+If you want to have a hosts folder, I recommend using the `-f` option.
+
+By default sensible will look for a sensible.yml in the folder you are executing sensible from.
+
+## Tasks
+Everything is basically a task, it manages packages, and the script to check and install the task.
+
+### Properties
+
+#### name
+This is name of the task, should be short and simple
+
+#### description
+This a longer description to help explain it in more detail what it does.
+
+#### require
+A task can require other things. Lets say you have a task that installs a frontend project, that can then require that you have a apache server installed to run. 
+
+**This property is optional**
+
+#### packages
+Here you can definethe packages a task should install. You define which type of package via the property name: `rpm`, `deb` or `aur`
+
+Example:
+
+```
+packages:
+  rpm: [btop] # RHEL based
+  deb: [btop] # Debian based
+  aur: [btop] # Arch linux based
+```
+
+**This property is optional**
+
+#### check
+This is the script you can use to check if the task was installed succesfully.
+
+You will most likely use this, if you are going to use the `script` property.
+
+**This property is optional**
+
+#### script
+This the install script for the task. Let's say you need to do a git clone, create a user, switch to that user etc.
+
+If this script exits with 0, it completed successfully
+
+**This property is optional**
+
+
+### Full example
+
+```yaml
+# .sensible/task/test.yml
+---
+name: Task example
+description: This installs an apache httpd server, shellopts gem
+require:
+  - .sensible/requirements/httpd # Remember, it's relative from execution path
+packages: # Optional if task does not require packages
+  deb: # Debian packages
+  aur: # Aur packages (Arch linux)
+  rpm: [httpd]
+check: |
+  # This is for a more complex check, like if you need to check a service is running, files exist, etc... 
+script: |
+  # Script is optional, as it's intended for tasks that require more than just installing various packages.
+  # Maybe you require things being installed in a certain order
+```
+
+
+
+
+
+
+
+### Future ideas
+
+#### Allow for ruby files
+I'm planning on allowing .rb-files too, for even more flexibility.
+
+#### Include other files
+It might be a nice feature to be able to include other files.

data/sensible.yml

@@ -1,23 +1,13 @@
-preTasks:
-  - test
-
 packages:
-  - name: httpd
-  - name: htop
-  - name: btop
-    env: 
-      - prod
-  - name: rvm
-    check: which rvm
+  rpm: [btop]
+
+
+tasks:
+  - name: Check whoami
+    user: sample
+    check: whoami
+    script: whoami
 
-requirements:
-  - name: Test requirement
-    check: which node
-    install: echo "install"
-  
-  - name: Test requirement that fails
-    check: exit 1
-    install: exit 1
-  
-postTasks:
-  - another
+  - .sensible/apps/project-frontend
+  - .sensible/apps/project-frontend-2
+  - .sensible/tasks/test

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: sensible-cli
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Mikkel Jensen
 bindir: exe
 cert_chain: []
-date: 2025-06-13 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: shellopts
@@ -15,14 +15,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.6.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.6.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: tty-which
   requirement: !ruby/object:Gem::Requirement
@@ -93,6 +99,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.0
 description: A small tool to manage projects, making shell scripts easier to manage,
   and faster to setup projects!
 email:
@@ -102,9 +136,13 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".idea/.gitignore"
+- ".idea/material_theme_project_new.xml"
+- ".idea/misc.xml"
+- ".idea/modules.xml"
+- ".idea/sensible-ruby.iml"
+- ".idea/vcs.xml"
 - ".rspec"
-- ".sensible/tasks/another.yml"
-- ".sensible/tasks/test.yml"
 - README.md
 - Rakefile
 - exe/sensible
@@ -113,8 +151,10 @@ files:
 - lib/sensible/package.rb
 - lib/sensible/parse.rb
 - lib/sensible/requirement.rb
+- lib/sensible/shell.rb
 - lib/sensible/task.rb
 - lib/sensible/version.rb
+- new-sensible-spec.md
 - sensible.yml
 - sig/sensible.rbs
 homepage: https://github.com/dasmikko/sensible-ruby
@@ -135,7 +175,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.5
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A small tool to manage projects.
 test_files: []

data/.sensible/tasks/another.yml

@@ -1,7 +0,0 @@
----
-name: Another test task
-description: This is a sample task, and this is its description
-install: |
-  echo "This is a multi line script"
-  echo "I should use a temp file to run"
-  notify-send "This is the post task that ran!"

data/.sensible/tasks/test.yml

@@ -1,4 +0,0 @@
----
-name: This is a sample task in a seperate file
-description: This is a sample task, and this is its description
-install: notify-send "This is the pre task that ran!"