rubino-agent 0.3.0

data/lib/rubino/cli/commands.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Rubino
+  module CLI
+    # Main Thor command class. All subcommands are registered here.
+    class Commands < Thor
+      # Without an explicit namespace, Thor's `tree` command derives one by
+      # underscoring the class name — "Rubino::CLI::Commands" becomes the
+      # mangled "rubino:c_l_i:commands" (the CLI acronym splits into
+      # c_l_i) (F12/F14). Pin a clean label instead.
+      namespace "rubino"
+
+      def self.exit_on_failure?
+        true
+      end
+
+      # Allow passing prompt directly as default task:
+      # rubino "my prompt"
+      def self.default_command
+        :chat
+      end
+
+      # Help flags recognized on any top-level command (#134).
+      HELP_FLAGS = ["--help", "-h"].freeze
+
+      # Intercept `--version`/`-v` at dispatch (#32). Thor otherwise routes a
+      # bare `rubino --version` to the default `chat` task, which treats the
+      # flag as a prompt and fails with an API-key error. Handle it here —
+      # print the version and exit — before any chat/credential handling.
+      #
+      # Likewise intercept `rubino <command> --help` (#134): Thor 1.x only maps
+      # a LEADING help flag to the help task, so `chat --help`/`prompt --help`
+      # used to fall through as an unknown option, become the positional
+      # prompt, and start a REAL agent run (provider call + memory writes).
+      # Reroute to Thor's own `help <command>` before option parsing. Thor
+      # subcommands (config/memory/sessions/jobs) already handle their own
+      # `--help` and keep their richer subcommand listing.
+      def self.start(given_args = ARGV, config = {})
+        if ["--version", "-v"].include?(given_args.first)
+          puts "rubino v#{Rubino::VERSION}"
+          return
+        end
+
+        cmd = given_args.first.to_s.tr("-", "_")
+        if given_args.drop(1).intersect?(HELP_FLAGS) && commands.key?(cmd) && !subcommands.include?(cmd)
+          return super(["help", cmd], config)
+        end
+
+        super
+      end
+
+      # Wrap subcommand help so `chat --help` / `prompt --help` stay within 80
+      # columns (#217). Thor's stock #print_options lays the flags and their
+      # descriptions out in a 2-column table padded to the WIDEST flag — and the
+      # boolean variants (`[--no-x], [--skip-x]`) push that column past 60, so
+      # every description row overflowed 80 (the longest hit 137) with no
+      # wrapping. Render each option as its flag line followed by the
+      # description wrapped + indented on its own line(s) instead: bounded by
+      # construction, and it reads cleaner than the ragged padded table.
+      HELP_WRAP_COLUMNS = 80
+      HELP_DESC_INDENT  = 6
+
+      def self.print_options(shell, options, group_name = nil)
+        return if options.empty?
+
+        shell.say(group_name ? "#{group_name} options:" : "Options:")
+        options.reject(&:hide).each do |option|
+          shell.say("  #{option.usage(0)}")
+          next unless option.description
+
+          wrap_help_description(option.description).each { |line| shell.say(line) }
+        end
+        shell.say ""
+      end
+
+      # Greedy word-wrap of a flag description to HELP_WRAP_COLUMNS, each line
+      # indented HELP_DESC_INDENT. Wrapped here (not via Thor's print_wrapped)
+      # so the bound is the fixed 80 the spec checks, not the live terminal
+      # width. A single word longer than the budget is emitted on its own line
+      # rather than dropped.
+      def self.wrap_help_description(description)
+        indent = " " * HELP_DESC_INDENT
+        budget = HELP_WRAP_COLUMNS - HELP_DESC_INDENT
+        lines  = []
+        line   = +""
+        description.to_s.split(/\s+/).each do |word|
+          if line.empty?
+            line << word
+          elsif line.length + 1 + word.length <= budget
+            line << " " << word
+          else
+            lines << (indent + line)
+            line = +word
+          end
+        end
+        lines << (indent + line) unless line.empty?
+        lines
+      end
+
+      desc "setup", "Initialize rubino configuration and database"
+      def setup
+        SetupCommand.new.execute
+      end
+
+      # ----------------------------------------------------------------
+      # chat — interactive and non-interactive
+      # ----------------------------------------------------------------
+      desc "chat [PROMPT]", "Chat with the agent (one-shot with -q)"
+
+      # One-shot / non-interactive
+      option :query,    aliases: "-q", type: :string, desc: "One-shot prompt (non-interactive)"
+
+      # Attach image(s) to the turn's native vision slot. Repeatable:
+      #   --image a.png --image b.jpg.
+      # A single-value, repeatable string (not a greedy array) so a trailing
+      # positional prompt — `--image pic.png "what is this?"` — stays the prompt
+      # instead of being swallowed as a second image. Works in both one-shot
+      # (-q) and interactive mode; @image tokens in the prompt itself are also
+      # honoured. Aligns with `llm`'s -a/--attachment.
+      option :image,    aliases: "-i", type: :string, repeatable: true,
+                        desc: "Attach image file to the prompt (repeatable)"
+
+      # Session management
+      option :session,  aliases: "-s", type: :string,  desc: "Resume session by ID"
+      option :resume,   aliases: "-r", type: :string,  desc: "Resume session by ID or title"
+      option :continue, aliases: "-c", type: :boolean, desc: "Resume most recent session"
+      option :new,                     type: :boolean,
+                                       desc: "Start a fresh session (bare `chat` resumes the last one by default)"
+
+      # Model / provider
+      option :model, aliases: "-m", type: :string, desc: "Override model (e.g. claude-sonnet-4-5)"
+      option :provider,                type: :string,  desc: "Override provider (e.g. bedrock, anthropic)"
+
+      # Behavior
+      option :yolo,                    type: :boolean, desc: "Skip all approval prompts"
+      option :max_turns,               type: :numeric, desc: "Max tool iterations per turn"
+      option :ignore_rules,            type: :boolean, desc: "Skip AGENTS.md and context files"
+
+      # Add extra allowed workspace roots at launch (repeatable), like Claude
+      # Code's --add-dir. Write/edit tools then accept files under any added
+      # root; an added dir's project context/skills are gated by folder-trust.
+      option :add_dir,                 type: :string, repeatable: true,
+                                       desc: "Add an extra allowed workspace directory (repeatable)"
+
+      def chat(prompt = nil)
+        # Support: rubino chat "prompt" as shorthand for -q
+        opts = options.to_h.merge(prompt ? { query: prompt } : {})
+        ChatCommand.new(opts).execute
+      end
+
+      # ----------------------------------------------------------------
+      # Shorthand: rubino prompt "my question"
+      # ----------------------------------------------------------------
+      desc "prompt PROMPT", "Run a one-shot prompt (alias for chat -q)"
+      option :model,        aliases: "-m", type: :string,  desc: "Override model"
+      option :provider,                    type: :string,  desc: "Override provider"
+      option :image,        aliases: "-i", type: :string, repeatable: true, desc: "Attach image file (repeatable)"
+      option :session,      aliases: "-s", type: :string,  desc: "Session ID to resume"
+      option :continue,     aliases: "-c", type: :boolean, desc: "Resume most recent session"
+      option :resume,       aliases: "-r", type: :string,  desc: "Resume by ID or title"
+      option :yolo,                        type: :boolean, desc: "Skip approval prompts"
+      option :max_turns,                   type: :numeric, desc: "Max tool iterations"
+      option :ignore_rules,                type: :boolean, desc: "Skip AGENTS.md/context files"
+      option :add_dir,                     type: :string, repeatable: true,
+                                           desc: "Add an extra allowed workspace directory (repeatable)"
+      def prompt(*args)
+        query = args.join(" ")
+        opts = options.to_h.merge(query: query)
+        ChatCommand.new(opts).execute
+      end
+
+      desc "config SUBCOMMAND", "Manage configuration"
+      subcommand "config", ConfigCommand
+
+      desc "memory SUBCOMMAND", "Manage persistent memories"
+      subcommand "memory", MemoryCommand
+
+      desc "sessions SUBCOMMAND", "Manage chat sessions"
+      subcommand "sessions", SessionCommand
+
+      desc "jobs SUBCOMMAND", "Manage background jobs"
+      subcommand "jobs", JobsCommand
+
+      desc "skills SUBCOMMAND", "Manage skills (list, show, enable, disable)"
+      subcommand "skills", SkillsCommand
+
+      desc "tools", "List available tools"
+      def tools
+        ToolsCommand.new.execute
+      end
+
+      desc "server", "Start the JSON API server"
+      option :port, type: :numeric, default: 4820, desc: "Port to listen on"
+      option :host, type: :string, desc: "Host/interface to bind (default 127.0.0.1; pass 0.0.0.0 to expose)"
+      option :api_key, type: :string, desc: "Bearer token required on every request"
+      def server
+        ServerCommand.new(options).execute
+      end
+
+      # The usage label matches the registered command name (tls_cert) so
+      # `--help` and `tree` render the SAME name (#20); Thor still dispatches
+      # the hyphenated spelling (`rubino tls-cert`) via its name normalization.
+      desc "tls_cert", "Print the self-signed TLS certificate PEM"
+      def tls_cert
+        $stdout.write(API::TLS.ensure_cert!)
+      end
+
+      desc "doctor", "Check system health"
+      def doctor
+        DoctorCommand.new.execute
+      end
+
+      desc "version", "Show version"
+      def version
+        Rubino.ui.info("rubino v#{Rubino::VERSION}")
+      end
+
+      desc "update", "Update rubino to the latest published version"
+      def update
+        ui = Rubino.ui
+        current = Rubino::VERSION
+
+        case Rubino::UpdateCheck.install_method
+        when :gem
+          ok = system(*Rubino::UpdateCheck.gem_update_command)
+          unless ok
+            ui.warning("gem update failed. If this is a permission error, re-run the installer or try `gem update --user-install #{Rubino::UpdateCheck::GEM_NAME}`.")
+            return
+          end
+          new_v = Rubino::UpdateCheck.installed_gem_version(Rubino::UpdateCheck::GEM_NAME)
+          if new_v && Gem::Version.new(new_v) > Gem::Version.new(current)
+            ui.info("rubino is now on v#{new_v} (was v#{current}).")
+            ui.status("Restart any running rubino sessions to pick up the new version.")
+          else
+            ui.info("rubino is already up to date (v#{current}).")
+          end
+        else
+          ui.warning("rubino wasn't installed from RubyGems (built from source / dev checkout).")
+          ui.status("Re-run the installer to update:")
+          ui.status("  curl -fsSL https://raw.githubusercontent.com/Jhonnyr97/rubino-agent/main/install.sh | bash")
+        end
+      ensure
+        # Drop the cached notice so the boot footer doesn't linger after update.
+        Rubino::UpdateCheck.clear_cache!
+      end
+    end
+  end
+end

data/lib/rubino/cli/config_command.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Rubino
+  module CLI
+    # Subcommands for managing configuration
+    class ConfigCommand < Thor
+      # Clean `tree`/help label instead of the underscored
+      # "rubino:c_l_i:config_command" Thor derives from the class name (F12).
+      namespace "rubino config"
+
+      def self.exit_on_failure?
+        true
+      end
+
+      desc "get KEY", "Get a configuration value (dot-notation; secrets masked)"
+      def get(key)
+        self.class.render_get(key, ui: Rubino.ui)
+      end
+
+      # ONE get rendering for both surfaces (#187): this CLI verb and the
+      # in-chat `/config get` (Commands::Executor). Resolves against the
+      # effective config (file merged over defaults), the same source `show`
+      # and the running agent use, so default-valued keys are returned instead
+      # of falsely reported "not found" (issue #36). A scalar intermediate
+      # node (e.g. descending into a String) has no #dig; treat such a path as
+      # "not found" rather than crashing. Secret-named keys render masked.
+      def self.render_get(key, ui:)
+        value =
+          begin
+            Rubino.configuration.dig(*key.split("."))
+          rescue TypeError
+            nil
+          end
+        if value.nil?
+          ui.warning("Key '#{key}' not found")
+        else
+          ui.info("#{key} = #{redact(value, key: key.split(".").last)}")
+        end
+      end
+
+      desc "set KEY VALUE", "Set a configuration value (dot-notation)"
+      def set(key, value)
+        writer = Config::Writer.new(config_path: config_path)
+        writer.set(key, value)
+        Rubino.ui.success("#{key} = #{value}")
+      rescue ConfigurationError => e
+        Rubino.ui.error(e.message)
+        exit(1)
+      end
+
+      desc "show", "Show full configuration (secrets masked)"
+      def show
+        self.class.render_show(ui: Rubino.ui)
+      end
+
+      # ONE full-config rendering for both surfaces (#187): this CLI verb and
+      # the in-chat `/config show` — with secret-named keys masked, which the
+      # clear-text dump never did (api_key landed verbatim in the scrollback).
+      def self.render_show(ui:)
+        ui.info(redact(Rubino.configuration.raw).to_yaml)
+      end
+
+      # Deep DISPLAY masking for config values (#187): a secret-named key's
+      # value renders as *** (Util::SecretsMask — the same heuristic approval
+      # prompts use), hashes/arrays are walked, and plain strings are scanned
+      # for inline `Bearer …`-style credentials. Display-only — the file and
+      # the live configuration keep the real values. Empty/nil values pass
+      # through unmasked so a *** never fakes a value that isn't set.
+      def self.redact(value, key: nil)
+        case value
+        when Hash  then value.to_h { |k, v| [k, redact(v, key: k)] }
+        when Array then value.map { |v| redact(v, key: key) }
+        when String
+          value.empty? ? value : Util::SecretsMask.mask_value(value, key: key)
+        else value
+        end
+      end
+
+      desc "path", "Show config file path"
+      def path
+        Rubino.ui.info(config_path)
+      end
+
+      private
+
+      # Resolve through the Loader so config get/set/path operate on exactly
+      # the file the server loads (RUBINO_HOME-aware), not a recomputed
+      # File.join off a YAML default.
+      def config_path
+        Config::Loader.new.config_path
+      end
+    end
+  end
+end

data/lib/rubino/cli/doctor_command.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+module Rubino
+  module CLI
+    # Health check command that verifies all system components are working.
+    #
+    # Doctor is a READ-ONLY diagnosis (#68): it must never create the home
+    # directory or the database file while checking them — a never-setup
+    # install is reported as "run 'rubino setup'", not silently materialized
+    # at the umask's permissions and then declared healthy.
+    #
+    # Exit status (#67): non-zero when one or more required checks did not
+    # pass, so CI/scripts can gate on `rubino doctor`.
+    class DoctorCommand
+      def execute
+        ui = Rubino.ui
+        ui.info("Running system diagnostics...")
+        ui.blank_line
+
+        # Required checks score the headline verdict — these are what a CLI user
+        # needs for a working install. The encryption key is SERVER-ONLY (JSON
+        # API / OAuth) and a CLI-only user never touches it, so it lives in a
+        # separate optional section and is NOT counted against the score (#143):
+        # a healthy default install reports all-green.
+        required = [
+          check_config,
+          check_database,
+          check_migrations,
+          check_directories,
+          check_provider_keys,
+          check_model_configured
+        ]
+
+        ui.blank_line
+        ui.info("Optional (API/OAuth server):")
+        optional = [check_encryption_key]
+
+        # Document converters are an optional in-process capability (#6): report
+        # which CORE formats can be read in-process (their optional gem is
+        # loadable), but never let an absent gem fail doctor — pure-ruby formats
+        # always work and missing extraction gems only narrow the supported set.
+        check_document_converters
+
+        # MCP servers are optional integrations (#90): report each configured
+        # server's reachability best-effort, but never let a down MCP server
+        # fail doctor — it is informational, not a required check, so non-MCP
+        # users (and MCP users with a flaky server) still exit 0.
+        check_mcp_servers if MCP.enabled?
+
+        ui.blank_line
+        passed = required.count { |c| c[:status] == :ok }
+        total = required.size
+        optional_unconfigured = optional.count { |c| c[:status] != :ok }
+
+        if passed == total
+          ui.success("All #{total} checks passed!")
+          if optional_unconfigured.positive?
+            ui.info("(#{optional_unconfigured} optional server check#{"s" if optional_unconfigured != 1} not configured — only needed to run the API/OAuth server)")
+          end
+        else
+          ui.warning("#{passed}/#{total} required checks passed")
+          # Scripts/CI gate on doctor: a failed required check must be a
+          # non-zero exit, not a green 0 under a red report (#67).
+          exit(1)
+        end
+      end
+
+      private
+
+      def check_config
+        ui = Rubino.ui
+        loader = Config::Loader.new
+
+        if loader.config_exists?
+          ui.success("Config file exists: #{loader.config_path}")
+          { name: "config", status: :ok }
+        else
+          ui.error("config file missing. Run 'rubino setup'")
+          { name: "config", status: :fail }
+        end
+      end
+
+      def check_database
+        ui = Rubino.ui
+        unless database_on_disk?
+          ui.error("database not initialized: #{Rubino.database.db_path}. Run 'rubino setup'")
+          return { name: "database", status: :fail }
+        end
+
+        if Rubino.database.healthy?
+          ui.success("Database accessible: #{Rubino.database.db_path}")
+          { name: "database", status: :ok }
+        else
+          ui.error("database not accessible")
+          { name: "database", status: :fail }
+        end
+      rescue StandardError => e
+        ui.error("database error: #{e.message}")
+        { name: "database", status: :fail }
+      end
+
+      def check_migrations
+        ui = Rubino.ui
+        unless database_on_disk?
+          ui.error("migrations not run — no database. Run 'rubino setup'")
+          return { name: "migrations", status: :fail }
+        end
+
+        migrator = Database::Migrator.new(Rubino.database)
+
+        if migrator.pending?
+          ui.warning("Pending migrations exist")
+          { name: "migrations", status: :warn }
+        else
+          ui.success("Migrations up to date")
+          { name: "migrations", status: :ok }
+        end
+      rescue StandardError => e
+        ui.error("migration check failed: #{e.message}")
+        { name: "migrations", status: :fail }
+      end
+
+      # Read-only guard for the two DB checks (#68): SQLite lazily CREATES the
+      # file (and its parent directory) on the first connection, so probing a
+      # never-setup home with `SELECT 1` would mutate it — and doctor would then
+      # report the empty, unmigrated database it just created as "accessible".
+      # A missing file is an uninitialized install: report it without touching
+      # the disk.
+      def database_on_disk?
+        db = Rubino.database
+        db.memory? || File.exist?(db.db_path)
+      end
+
+      def check_directories
+        ui = Rubino.ui
+        home = Rubino.home_path
+
+        if File.directory?(home)
+          ui.success("Home directory exists: #{home}")
+          { name: "directories", status: :ok }
+        else
+          ui.error("home directory missing: #{home}. Run 'rubino setup'")
+          { name: "directories", status: :fail }
+        end
+      end
+
+      # Verifies the credentials for the ACTUALLY configured provider resolve —
+      # not a hardcoded ENV allowlist. A tenant on an openai_compatible backend
+      # (ollama, vllm, a hosted gateway, …) configures its key under
+      # providers.<name>.api_key in config.yml; the old hardcoded check ignored
+      # that and warned "No API keys found" on a correctly-configured tenant.
+      def check_provider_keys
+        ui = Rubino.ui
+        provider = LLM::CredentialCheck.resolved_provider
+
+        if LLM::CredentialCheck.usable?
+          ui.success("API key configured (#{provider})")
+          { name: "provider_keys", status: :ok }
+        else
+          ui.warning("No credentials found for provider '#{provider}'")
+          { name: "provider_keys", status: :warn }
+        end
+      end
+
+      def check_model_configured
+        ui = Rubino.ui
+        model = Rubino.configuration.model_default
+
+        if model && !model.empty?
+          ui.success("Model configured: #{model}")
+          { name: "model", status: :ok }
+        else
+          ui.error("no model configured")
+          { name: "model", status: :fail }
+        end
+      end
+
+      # Verifies the OAuth-token encryption key is present and well-formed
+      # WITHOUT crashing doctor itself: server boot uses Boot::EncryptionKey
+      # for the hard fail-fast path, but doctor must keep running so the
+      # operator sees every other check that did pass.
+      #
+      # The key is only needed by the JSON API / OAuth (encrypted-token) path;
+      # a CLI-only user never touches it. So a MISSING key is a :warn scoped to
+      # that path, not a scary red :fail that makes a healthy CLI install look
+      # broken (F4). A key that IS set but malformed is still a real :fail —
+      # that's a misconfiguration the operator must fix before the server boots.
+      def check_encryption_key
+        ui = Rubino.ui
+        OAuth::TokenEncryptor.from_env
+        ui.success("Encryption key configured")
+        { name: "encryption_key", status: :ok }
+      rescue OAuth::TokenEncryptor::KeyMissingError
+        ui.warning("RUBINO_ENCRYPTION_KEY not set (only needed for the API/OAuth server)")
+        { name: "encryption_key", status: :warn }
+      rescue ArgumentError => e
+        ui.error("RUBINO_ENCRYPTION_KEY invalid: #{e.message}")
+        { name: "encryption_key", status: :fail }
+      end
+
+      # Best-effort MCP reachability report (#90). Starts each configured
+      # server, health-checks it, and stops everything again — doctor stays
+      # read-only and leaves no child processes behind. Deliberately NOT part
+      # of the required score: a server that fails to start already warned via
+      # Manager#start_server, a started-but-dead one warns here, and neither
+      # flips the exit status. Any unexpected error degrades to a warning so
+      # the MCP section can never break doctor itself.
+      def check_mcp_servers
+        ui = Rubino.ui
+        ui.blank_line
+        ui.info("Optional (MCP servers, experimental):")
+
+        servers = Rubino.configuration.dig("mcp", "servers") || {}
+        manager = MCP::Manager.new
+        servers.each { |name, server_config| manager.start_server(name, server_config) }
+
+        manager.health_check.each do |status|
+          if status[:alive]
+            ui.success("MCP server '#{status[:name]}' reachable")
+          else
+            ui.warning("MCP server '#{status[:name]}' not reachable")
+          end
+        end
+        manager.stop_all!
+      rescue StandardError => e
+        ui.warning("MCP check failed: #{e.message}")
+      end
+
+      # Non-scoring report of the in-process document-conversion capability
+      # (#6), mirroring the MCP "Optional (…)" pattern. Pure-ruby formats are
+      # always green; a gem-backed format whose optional gem isn't installed is
+      # a warning (never a fail), so a healthy default install never shows red
+      # for a capability it can extend by installing an optional gem.
+      def check_document_converters
+        ui = Rubino.ui
+        ui.blank_line
+        ui.info("Optional (document converters, in-process via read_attachment):")
+
+        Rubino::Documents::Registry.capabilities.each do |format, available|
+          if available
+            ui.success("#{format} supported")
+          else
+            ui.warning("#{format} not available (install its optional gem to enable)")
+          end
+        end
+      rescue StandardError => e
+        ui.warning("Document-converter check failed: #{e.message}")
+      end
+    end
+  end
+end

data/lib/rubino/cli/jobs_command.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Rubino
+  module CLI
+    # Subcommands for managing the job queue
+    class JobsCommand < Thor
+      # Clean `tree`/help label instead of the underscored class-name default (F12).
+      namespace "rubino jobs"
+
+      def self.exit_on_failure?
+        true
+      end
+
+      desc "list", "List jobs in queue"
+      option :status, type: :string, desc: "Filter by status (queued, running, completed, failed)"
+      option :limit, type: :numeric, default: 20, desc: "Max results"
+      def list
+        Rubino.ensure_database_ready!
+        queue = Jobs::Queue.new
+        jobs = queue.list(status: options[:status], limit: options[:limit])
+
+        if jobs.empty?
+          Rubino.ui.info("No jobs found.")
+          return
+        end
+
+        self.class.render_list(jobs, ui: Rubino.ui)
+      end
+
+      # ONE jobs-table rendering for both surfaces (#187): this CLI verb and
+      # the in-chat /jobs list (Commands::Executor).
+      def self.render_list(jobs, ui:)
+        rows = jobs.map do |j|
+          [j[:id][0..7], j[:type], j[:status], j[:attempts].to_s, j[:run_at]]
+        end
+
+        ui.table(headers: %w[ID Type Status Attempts RunAt], rows: rows)
+      end
+
+      desc "process", "Run pending jobs now (manual mode)"
+      option :limit, type: :numeric, default: 10, desc: "Max jobs to process"
+      def process
+        runner = Jobs::Runner.new
+        processed = runner.run_pending(limit: options[:limit])
+        Rubino.ui.success("Processed #{processed} job(s)")
+      end
+
+      desc "worker", "Start a background worker loop"
+      def worker
+        Rubino.ui.info("Starting job worker (poll every #{Rubino.configuration.jobs_poll_interval}s)...")
+        Rubino.ui.info("Press Ctrl+C to stop.")
+
+        worker = Jobs::Worker.new
+        worker.start
+      end
+    end
+  end
+end