ruby_raider 4.0.1 → 4.1.0

data/lib/utilities/flows/scheduler.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+require 'rbconfig'
+require_relative 'next_run'
+require_relative 'run_log'
+require_relative 'schedule'
+require_relative 'schedule_store'
+require_relative 'os/command_runner'
+require_relative 'os/launchd'
+require_relative 'os/task_scheduler'
+require_relative 'os/linux'
+
+module RubyRaider
+  module Flows
+    # `raider flow schedule | unschedule | schedules`: keeps the OS scheduler entries and
+    # .raider/flows/schedules.yml in step. The OS entry is installed first and the yml written after,
+    # so the yml never names an entry the OS scheduler refused.
+    # :reek:TooManyInstanceVariables { max_instance_variables: 6 } -- the project, its store, the adapter and the injected streams and clock
+    class Scheduler
+      NOT_SET_UP = 'Flows are not set up in this project: run raider flow init'
+      RUBY_NOT_FOUND = 'Ruby not found: re-schedule'
+      FLOW_NOT_FOUND = 'flow not found: unschedule'
+      LAST = %w[status finished_at trigger failed_step results_dir].freeze
+      TIME = '%a %-d %b %H:%M'
+
+      # The OS scheduler for this machine; only Linux asks the system (is the user's systemd there?)
+      def self.adapter(runner: Os::CommandRunner.new, host_os: RbConfig::CONFIG['host_os'])
+        case host_os
+        when /darwin/ then Os::Launchd.new(runner: runner)
+        when /mswin|mingw|cygwin/ then Os::TaskScheduler.new(runner: runner)
+        when /linux/ then Os::Linux.pick(runner)
+        else raise Error, "Scheduling flows is not supported on #{host_os}"
+        end
+      end
+
+      # adapter: nil picks the OS scheduler on first use, so a command refused earlier never touches it
+      def initialize(project, adapter: nil, store: ScheduleStore.new(project), out: $stdout, err: $stderr, now: -> { Time.now })
+        @project = project
+        @adapter = adapter
+        @store = store
+        @out = out
+        @err = err
+        @now = now
+      end
+
+      def schedule(name, every:, at: nil, on: nil, retries: 0, inputs: [], notify: false)
+        @project.flow_file(name)
+        raise Error, NOT_SET_UP unless @project.set_up?
+
+        now = @now.call
+        schedule = Schedule.build(project: @project, name: name, every: every, at: at, on: on, retries: retries,
+                                  inputs: inputs, notify: notify, now: now)
+        flow_dir(name)
+        @store.writable!
+        old = @store.find(name)
+        adapter.install(schedule)
+        save(schedule)
+        prefix = old ? "Replaced the schedule for #{name}" : "Scheduled #{name}"
+        @out.puts("#{prefix}: #{rule(schedule)}. Next run #{NextRun.after(schedule, now).strftime(TIME)}.")
+      end
+
+      def unschedule(name)
+        raise Error, "Invalid flow name #{name.inspect}: use 1 to 60 of a-z, 0-9 and _ (not env)" unless Flows.valid_name?(name)
+
+        # The OS entry first: when the scheduler refuses, the yml entry stays to retry with.
+        # from_h is strict, so a stored entry's os_id is always this one.
+        label = adapter.label
+        was_there = adapter.remove(Schedule.os_id_for(@project.root, name))
+        removed = delete(name, label)
+        raise Error, "No schedule for #{name}" unless removed || was_there
+
+        @out.puts(was_there ? "Unscheduled #{name}" : "Unscheduled #{name} (it was already gone from #{label})")
+        return unless removed.is_a?(ScheduleStore::Removed)
+
+        @err.puts("The schedules.yml entry for #{name} could not be read: a #{label} entry made from a different project path may remain")
+      end
+
+      def schedules(json: false)
+        now = @now.call
+        listed = @store.all
+        rows = listed.map { |schedule| row(schedule, now) } + unlisted_rows(listed.map(&:name))
+        return @out.puts(JSON.generate(rows.map { |entry| entry[:json] })) if json
+        return @out.puts('No schedules yet: raider flow schedule <name> --every day --at 08:00') if rows.empty?
+
+        rows.each { |entry| @out.puts(Flows.printable(entry[:text])) }
+        note = adapter.respond_to?(:missed_runs_note) ? adapter.missed_runs_note : nil
+        @out.puts(note) if note
+      end
+
+      private
+
+      def adapter = @adapter ||= Scheduler.adapter
+
+      # Writes the yml; when that fails the OS entry just installed is removed, so neither names the flow
+      def save(schedule)
+        @store.save(schedule)
+      rescue Error, SystemCallError => e
+        label = adapter.label
+        begin
+          adapter.remove(schedule.os_id)
+        rescue Error => remove_error
+          raise Error, "#{e.message} (and removing the #{label} entry failed: #{remove_error.message})"
+        end
+        raise Error, "#{e.message}: the #{label} entry was removed too, so #{schedule.name} is not scheduled"
+      end
+
+      # The OS entry is gone by now: say so when the yml can't be written
+      def delete(name, label)
+        @store.delete(name)
+      rescue Error, SystemCallError => e
+        raise Error, "#{e.message}: the #{label} entry was already removed, but schedules.yml still lists #{name}"
+      end
+
+      # .raider/flows/<name>/ for scheduler.log: 0700 folders that are not links, as flows/support/run.rb makes them
+      def flow_dir(name)
+        [ScheduleStore::DIR, "#{ScheduleStore::DIR}/#{name}"].each { |relative| private_dir(relative) }
+      end
+
+      def private_dir(relative)
+        dir = @project.path(relative)
+        FileUtils.mkdir_p(dir)
+        raise Error, "#{relative} must be a folder, not a link" unless File.lstat(dir).directory?
+
+        File.chmod(0o700, dir)
+      rescue SystemCallError => e
+        raise Error, "Could not make #{relative}: #{e.message}"
+      end
+
+      def row(schedule, now)
+        name = schedule.name
+        next_run = NextRun.after(schedule, now)
+        state = os_state(schedule)
+        last = last_run(name)
+        json = { 'name' => name, 'every' => schedule.every, 'at' => schedule.at, 'on' => schedule.on,
+                 'retries' => schedule.retries, 'inputs' => schedule.inputs, 'notify' => schedule.notify, 'next_run_at' => next_run.iso8601,
+                 'os_state' => state, 'last' => last }
+        { json: json, text: line(name, rule(schedule), "next #{next_run.strftime(TIME)}", last, state) }
+      end
+
+      # Flows the OS scheduler still runs for this project although schedules.yml has no entry for them
+      def unlisted_rows(listed)
+        (@project.flow_names - listed).filter_map do |name|
+          next unless present?(Schedule.os_id_for(@project.root, name))
+
+          state = 'missing from schedules.yml'
+          last = last_run(name)
+          json = { 'name' => name, 'every' => nil, 'at' => nil, 'on' => nil, 'retries' => nil, 'inputs' => nil, 'notify' => nil,
+                   'next_run_at' => nil, 'os_state' => state, 'last' => last }
+          { json: json, text: line(name, '-', '-', last, state) }
+        end
+      end
+
+      # A flow whose state can't be read is left out: only a listed schedule gets an unknown row
+      def present?(os_id)
+        adapter.present?(os_id)
+      rescue Error
+        false
+      end
+
+      # The OS entry runs `<ruby> <bundle> ...`: ruby is executed, bundle is only read by it
+      def os_state(schedule)
+        ruby = schedule.ruby
+        bundle = schedule.bundle
+        return RUBY_NOT_FOUND unless File.file?(ruby) && File.executable?(ruby) && File.file?(bundle) && File.readable?(bundle)
+        return FLOW_NOT_FOUND unless File.file?(@project.path("flows/#{schedule.name}_flow.rb"))
+
+        adapter.present?(schedule.os_id) ? 'ok' : "missing from #{adapter.label}"
+      rescue Error => e
+        "unknown (#{e.message})"
+      end
+
+      def rule(schedule) = schedule.notify ? "#{schedule.rule_text} (notify)" : schedule.rule_text
+
+      def last_run(name)
+        last = RunLog.new(@project, name).last_result
+        last && LAST.to_h { |key| [key, last[key]] }
+      end
+
+      def line(name, rule, next_run, last, state)
+        result = last ? "#{last['status']}  #{last['finished_at']}" : 'never run'
+        "#{name.ljust(30)}  #{rule}  #{next_run}  #{result}  #{state}"
+      end
+    end
+  end
+end

data/lib/version

@@ -1 +1 @@
-4.0.1
+4.1.0

data/sig/commands/flow_commands.rbs

@@ -0,0 +1,13 @@
+# Type definitions for FlowCommands
+class FlowCommands < Thor
+  def init: () -> void
+  def run_flow: (String name) -> void
+  def list: () -> void
+  def schedule: (String name) -> void
+  def unschedule: (String name) -> void
+  def schedules: () -> void
+  def project: () -> RubyRaider::Flows::Project
+  def scheduler: () -> RubyRaider::Flows::Scheduler
+  def list_line: (Hash[String, untyped] flow) -> String
+  def stop: (RubyRaider::Flows::Error error) -> bot
+end

data/sig/ruby_raider.rbs

@@ -1,6 +1,8 @@
 # Type definitions for main RubyRaider entry point
 module RubyRaider
   class Raider < Thor
+    def self.start: (?Array[String] given_args, ?Hash[Symbol, untyped] config) -> void
+
     def current_version: () -> String
 
     def new: (String project_name) -> void

data/sig/utilities/flows/next_run.rbs

@@ -0,0 +1,15 @@
+module RubyRaider
+  module Flows
+    module NextRun
+      WDAYS: Array[String]
+      SEARCH_DAYS: Integer
+      SEARCH_MINUTES: Integer
+
+      def self?.after: (Schedule schedule, Time now) -> Time
+      def self?.next_minute: (Integer minute, Time now) -> Time
+      def self?.next_day: (Schedule schedule, Time now) -> Time
+      def self?.local: (Date date, Integer hour, Integer minute) -> Time
+      def self?.wall: (Time time) -> Array[Integer]
+    end
+  end
+end

data/sig/utilities/flows/notifier.rbs

@@ -0,0 +1,29 @@
+module RubyRaider
+  module Flows
+    class Notifier
+      MAX: Integer
+      TIMEOUT: Integer
+      OSASCRIPT: Array[String]
+      NOTIFY_SEND: Array[String]
+      MARKUP: Hash[String, String]
+      TOAST_SCRIPT: String
+      POWERSHELL_ARGS: Array[String]
+
+      @runner: Os::CommandRunner
+      @host_os: String
+      @err: IO | StringIO
+      @warned: bool
+      @powershell: String
+
+      def self.powershell: () -> String
+
+      def initialize: (?runner: Os::CommandRunner, ?host_os: String, ?err: IO | StringIO, ?powershell: String) -> void
+      def notify: (String title, String message) -> bool
+
+      private
+
+      def clean: (untyped text) -> String
+      def failed: (String reason) -> false
+    end
+  end
+end

data/sig/utilities/flows/os/command_runner.rbs

@@ -0,0 +1,27 @@
+module RubyRaider
+  module Flows
+    module Os
+      class CommandRunner
+        MISSING: Integer
+        TIMED_OUT: Integer
+
+        class Result
+          attr_reader stdout: String
+          attr_reader stderr: String
+          attr_reader exitstatus: Integer
+
+          def initialize: (stdout: String, stderr: String, exitstatus: Integer) -> void
+          def success?: () -> bool
+        end
+
+        def call: (*String argv, ?stdin_data: String?, ?env: Hash[String, String], ?timeout: Numeric?) -> Result
+
+        private
+
+        def reader: (IO io) -> Thread
+        def feed: (IO stdin, String? data) -> void
+        def timed_out: (String command, Numeric? timeout, untyped wait) -> Result
+      end
+    end
+  end
+end

data/sig/utilities/flows/os/cron.rbs

@@ -0,0 +1,34 @@
+module RubyRaider
+  module Flows
+    module Os
+      class Cron
+        CRONTAB: String
+        TAG: String
+        MAX_LINE: Integer
+        OS_ID: Regexp
+
+        @runner: CommandRunner
+
+        def initialize: (?runner: CommandRunner) -> void
+        def label: () -> String
+        def missed_runs_note: () -> String
+        def line: (Schedule schedule) -> String
+        def install: (Schedule schedule) -> true
+        def remove: (String os_id) -> bool
+        def present?: (String os_id) -> bool
+        def usable?: () -> bool
+
+        private
+
+        def fields: (Schedule schedule) -> String
+        def weekday: (String day) -> Integer
+        def escape: (String word) -> String
+        def without: (String table, String os_id) -> [String, bool]
+        def our_command?: (String text, String? name) -> bool
+        def read: () -> String
+        def save: (String table) -> void
+        def checked_os_id: (untyped os_id) -> String
+      end
+    end
+  end
+end

data/sig/utilities/flows/os/launchd.rbs

@@ -0,0 +1,45 @@
+module RubyRaider
+  module Flows
+    module Os
+      class Launchd
+        LAUNCHCTL: String
+        PLUTIL: String
+        NOFOLLOW: Integer
+        ESCAPES: Hash[String, String]
+        HEADER: String
+        OS_ID: Regexp
+
+        @runner: CommandRunner
+        @home: String
+        @uid: Integer
+
+        def initialize: (?runner: CommandRunner, ?home: String, ?uid: Integer) -> void
+        def label: () -> String
+        def plist: (Schedule schedule) -> String
+        def plist_path: (String os_id) -> String
+        def install: (Schedule schedule) -> true
+        def remove: (String os_id) -> bool
+        def present?: (String os_id) -> bool
+
+        private
+
+        def launchctl: (*String args) -> CommandRunner::Result
+        def domain: () -> String
+        def service: (String os_id) -> String
+        def unlink: (String path) -> bool
+        def agents_dir: () -> String
+        def checked_os_id: (untyped os_id) -> String
+        def escape: (untyped text) -> String
+        def string: (untyped text) -> Array[String]
+        def integer: (Integer number) -> Array[String]
+        def array: (Array[Array[String]] items) -> Array[String]
+        def dict: (Array[[String, Array[String]]] pairs) -> Array[String]
+        def indent: (Array[String] lines) -> Array[String]
+        def calendar: (Schedule schedule) -> Array[String]
+        def weekday: (String day) -> Integer
+        def discard: (String path) -> String
+        def write: (String path, String text) -> void
+      end
+    end
+  end
+end

data/sig/utilities/flows/os/linux.rbs

@@ -0,0 +1,27 @@
+module RubyRaider
+  module Flows
+    module Os
+      class Linux
+        @primary: Systemd | Cron
+        @other: Cron?
+        @systemd: Systemd
+
+        def self.pick: (?CommandRunner runner) -> Linux
+
+        def initialize: (?runner: CommandRunner, ?systemd: Systemd, ?cron: Cron) -> void
+        def label: () -> String
+        def missed_runs_note: () -> String?
+        def install: (Schedule schedule) -> true
+        def remove: (String os_id) -> bool
+        def present?: (String os_id) -> bool
+
+        private
+
+        def stranded?: (String os_id) -> bool
+        def refuse_stranded: (String os_id) -> void
+
+        def other_present?: (String os_id) -> bool
+      end
+    end
+  end
+end

data/sig/utilities/flows/os/systemd.rbs

@@ -0,0 +1,43 @@
+module RubyRaider
+  module Flows
+    module Os
+      class Systemd
+        SYSTEMCTL: String
+        NOFOLLOW: Integer
+        QUOTED: Hash[String, String]
+        CALENDAR: Hash[String, String]
+        OS_ID: Regexp
+        UNSAFE_PATH: Regexp
+
+        @runner: CommandRunner
+        @home: String
+        @config_home: String?
+
+        def initialize: (?runner: CommandRunner, ?home: String, ?config_home: String?) -> void
+        def label: () -> String
+        def missed_runs_note: () -> nil
+        def service: (Schedule schedule) -> String
+        def timer: (Schedule schedule) -> String
+        def unit_path: (String os_id, String kind) -> String
+        def install: (Schedule schedule) -> true
+        def remove: (String os_id) -> bool
+        def present?: (String os_id) -> bool
+        def usable?: () -> bool
+        def unit_files?: (String os_id) -> bool
+
+        private
+
+        def systemctl: (*String args) -> CommandRunner::Result
+        def units_dir: () -> String
+        def checked_os_id: (untyped os_id) -> String
+        def checked_path: (String path) -> void
+        def quote: (String text) -> String
+        def specifiers: (String text) -> String
+        def unlink: (String path) -> bool
+        def discard: (String os_id) -> String
+        def write: (Hash[String, String] texts) -> void
+        def temp_file: (String path, String text) -> String
+      end
+    end
+  end
+end

data/sig/utilities/flows/os/task_scheduler.rbs

@@ -0,0 +1,53 @@
+module RubyRaider
+  module Flows
+    module Os
+      class TaskScheduler
+        interface _Clock
+          def now: () -> Time
+        end
+
+        FOLDER: String
+        ESCAPES: Hash[String, String]
+        NAMESPACE: String
+        OS_ID: Regexp
+        NEEDS_QUOTES: Regexp
+        GLOB: Regexp
+        EXPANDS: Regexp
+        DAY_NAMES: Array[String]
+
+        @runner: CommandRunner
+        @clock: _Clock
+        @schtasks: String
+
+        def self.quote: (String arg) -> String
+        def self.glob_quote: (String arg) -> String
+        def self.odd_doubled: (String slashes) -> String
+        def self.join: (Array[String] args) -> String
+
+        def initialize: (?runner: CommandRunner, ?clock: _Clock, ?schtasks: String) -> void
+        def label: () -> String
+        def task_name: (untyped os_id) -> String
+        def task_xml: (Schedule schedule) -> String
+        def install: (Schedule schedule) -> true
+        def remove: (String os_id) -> bool
+        def present?: (String os_id) -> bool
+
+        private
+
+        def schtasks: (*String args) -> CommandRunner::Result
+        def list: () -> CommandRunner::Result
+        def listed?: (CommandRunner::Result listing, String name) -> bool
+        def refuse_expansion: (Schedule schedule) -> void
+        def checked_os_id: (untyped os_id) -> String
+        def escape: (untyped value) -> String
+        def text: (String name, untyped value) -> Array[String]
+        def element: (String tag, Array[untyped] children) -> Array[String]
+        def indent: (Array[String] lines) -> Array[String]
+        def trigger: (Schedule schedule) -> Array[untyped]
+        def calendar: (Schedule schedule, String every) -> Array[String]
+        def settings: () -> Array[Array[String]]
+        def action: (Schedule schedule) -> Array[Array[String]]
+      end
+    end
+  end
+end

data/sig/utilities/flows/project.rbs

@@ -0,0 +1,46 @@
+module RubyRaider
+  module Flows
+    NAME: Regexp
+    RESERVED: Array[String]
+
+    def self.valid_name?: (untyped name) -> bool
+    def self.printable: (untyped text) -> String
+
+    class Error < StandardError
+      attr_reader exit_code: Integer
+
+      def initialize: (String message, ?exit_code: Integer) -> void
+    end
+
+    class Project
+      UNSUPPORTED: String
+      GITIGNORE_LINES: Array[String]
+      TEMPLATES: Hash[String, String]
+      PIN: Regexp
+      FLOWS_PIN: Array[Integer]
+
+      attr_reader root: String
+
+      def initialize: (String path) -> void
+      def path: (String relative) -> String
+      def flow_file: (String name) -> String
+      def flow_names: () -> Array[String]
+      def set_up?: () -> bool
+      def unsupported_reason: () -> String?
+      def init: (?out: IO | StringIO, ?err: IO | StringIO) -> Integer
+
+      private
+
+      def template_dir: () -> String
+      def read: (String relative) -> String?
+      def selenium?: (String gemfile) -> bool
+      def runtime?: () -> bool
+      def old_pin?: (String gemfile) -> bool
+      def write_templates: () -> Array[String]
+      def add_gitignore_lines: () -> Array[String]
+      def pin_gem: () -> bool
+      def warn_unknown_pin: (IO | StringIO err) -> void
+      def report: (IO | StringIO out, Array[String] created, Array[String] updated, bool pinned) -> void
+    end
+  end
+end

data/sig/utilities/flows/run_log.rbs

@@ -0,0 +1,22 @@
+module RubyRaider
+  module Flows
+    class RunLog
+      MAX_BYTES: Integer
+      NOFOLLOW: Integer
+      NONBLOCK: Integer
+      SUMMARY: Array[String]
+
+      def self.summaries: (Project project) -> Array[Hash[String, untyped]]
+
+      def initialize: (Project project, String name) -> void
+      def lines: () -> Array[Hash[String, untyped]]
+      def last: () -> Hash[String, untyped]?
+      def last_result: () -> Hash[String, untyped]?
+      def find: (String run_id) -> Hash[String, untyped]?
+
+      private
+
+      def tail: () -> String
+    end
+  end
+end

data/sig/utilities/flows/runner.rbs

@@ -0,0 +1,35 @@
+module RubyRaider
+  module Flows
+    class Runner
+      EXIT_CODES: Hash[String, Integer]
+      INPUT: Regexp
+      INPUT_RULE: String
+      TRIGGERS: Array[String]
+      RETRY_WAIT: Integer
+
+      def self.spawn: (Hash[String, String?] env, Array[String] argv, String chdir) -> Integer?
+      def self.stopped: () -> bool?
+      def self.stopped=: (bool) -> bool
+      def self.interrupt: (Integer pid) -> void
+
+      def initialize: (Project project, ?out: IO | StringIO, ?spawner: untyped, ?sleeper: untyped, ?notifier: untyped) -> void
+      def run: (String name, ?headed: bool?, ?retries: untyped, ?inputs: Array[String]?, ?trigger: String, ?notify: bool) -> Integer
+
+      private
+
+      def attempt_runs: (String name, Integer attempts, Hash[Symbol, untyped] options) -> String
+      def notify_failure: (String name, String status, String trigger) -> bool
+      def start_output: (String name, String trigger) -> String
+      def stopped: (String name, String status) -> String
+      def attempt_run: (String name, Integer attempt, Hash[Symbol, untyped] options) -> String
+      def run_env: (String name, Integer attempt, String run_id, Hash[Symbol, untyped] options) -> Hash[String, String?]
+      def input_env: (Array[String]? inputs) -> Hash[String, String]
+      def checked_trigger: (String trigger) -> String
+      def checked_retries: (untyped retries) -> Integer
+      def report: (String name, Hash[String, untyped]? line, Integer? code) -> void
+      def outcome: (Hash[String, untyped] line) -> String
+      def failed_step: (untyped step) -> String
+      def duration: (Hash[String, untyped] line) -> (Float | String)
+    end
+  end
+end

data/sig/utilities/flows/schedule.rbs

@@ -0,0 +1,61 @@
+module RubyRaider
+  module Flows
+    class Schedule
+      EVERY: Array[String]
+      DAYS: Array[String]
+      DAYS_RULE: String
+      CLOCK: Regexp
+      MINUTE: Regexp
+      GEM_ENV: Array[String]
+      SYSTEM_PATH: Array[String]
+      OS_ID_PREFIX: String
+      KEYS: Array[String]
+
+      attr_reader name: String
+      attr_reader every: String
+      attr_reader at: String
+      attr_reader on: String?
+      attr_reader retries: Integer
+      attr_reader inputs: Array[String]
+      attr_reader notify: bool
+      attr_reader os_id: String
+      attr_reader ruby: String
+      attr_reader bundle: String
+      attr_reader gem_env: Hash[String, String]
+      attr_reader project_root: String
+      attr_reader created_at: String
+
+      def self.build: (project: Project, name: String, every: String, ?at: String?, ?on: String?, ?retries: untyped, ?inputs: Array[String], ?notify: bool, ?now: Time) -> Schedule
+      def self.from_h: (untyped hash, String project_root) -> Schedule
+      def self.os_id_for: (String project_root, String name) -> String
+      def self.bundle_path: () -> String
+      def self.captured_gem_env: () -> Hash[String, String]
+
+      def initialize: (name: untyped, every: untyped, at: untyped, on: untyped, retries: untyped, inputs: untyped, os_id: untyped, ruby: untyped, bundle: untyped, gem_env: untyped, project_root: untyped, created_at: untyped, ?notify: untyped) -> void
+      def hour: () -> Integer
+      def minute: () -> Integer
+      def days: () -> Array[String]
+      def argv: () -> Array[String]
+      def env: () -> Hash[String, String]
+      def working_directory: () -> String
+      def log_path: () -> String
+      def rule_text: () -> String
+      def to_h: () -> Hash[String, untyped]
+
+      private
+
+      def checked_name: (untyped name) -> String
+      def checked_every: (untyped every) -> String
+      def checked_at: (untyped at) -> String
+      def clock: (untyped at) -> String
+      def checked_on: (untyped on) -> String?
+      def checked_retries: (untyped retries) -> Integer
+      def checked_inputs: (untyped inputs) -> Array[String]
+      def checked_notify: (untyped notify) -> bool
+      def checked_os_id: (untyped os_id) -> String
+      def checked_path: (String label, untyped path) -> String
+      def checked_gem_env: (untyped gem_env) -> Hash[String, String]
+      def checked_text: (String label, untyped text) -> String
+    end
+  end
+end