agents_control 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7cbdfdaec647d99052be4572b93c02e8a1ba8f1169219a85c3abebb1ce1d794b
-  data.tar.gz: 5d486d2543a88f451eec31e8261ddf8fafb8170446f09f1f13596b07e639f19a
+  metadata.gz: cce6dbc39dbec059d87d6f739af51d705b2e11e8b6c11225dd0021c37461f17f
+  data.tar.gz: 646165dca05e1718512e7d8d065d2c76568618429999f5eb15c7e58fa9dfab93
 SHA512:
-  metadata.gz: e47eca628d62039dd339691b713ad2b123f5fe9205b0394f623fe51806cbb0711b3ee93f5708548855049d6ebf3631776276e8f21b3b977e776392f7bb842be1
-  data.tar.gz: cdec6b32aade79e9b165c72ac9fc121116b1a90ab1c7e16066737561653c9e5090ab87b593e55da04ca78dbe02099a4903bc626b008fe16170a448a65ab8ecf3
+  metadata.gz: d12b481351f8479279aa6867c2206609392d561236cd3680eed567272a496bfff8884ec0f3ebf72e50f1f9c4cac167882886c6087d9c011edda476b6e0229c3e
+  data.tar.gz: 907ff99d3b625927e0fba4b79a7aaf4010cd3875b00e6fe5f1d6b7d8e0d2756d34d0e1598cd9af73543cfe67041de7949ee2cf8c6ca080f8ddc885fd35b5b49a

data/lib/agents_control/channels/telegram/api.rb

@@ -242,10 +242,16 @@ module AgentsControl
           raise NetworkError, e.message
         end
 
+        # SystemCallError as a family rather than a list of Errno
+        # constants. The list was a bet on knowing every errno a network
+        # stack can raise, and it lost: Errno::EADDRNOTAVAIL — "can't
+        # assign requested address", what a VPN reconnecting produces —
+        # wasn't on it, so it escaped as itself instead of arriving as
+        # Unavailable, and killed the polling thread outright. The
+        # daemon stayed up with its port open and simply stopped hearing
+        # Telegram, for days, with nothing in the log after the trace.
         NETWORK_ERRORS = [
-          Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::EHOSTUNREACH,
-          Errno::ENETUNREACH, Errno::ETIMEDOUT, Errno::EPIPE,
-          SocketError, Timeout::Error, OpenSSL::SSL::SSLError, IOError
+          SystemCallError, SocketError, Timeout::Error, OpenSSL::SSL::SSLError, IOError
         ].freeze
       end
     end

data/lib/agents_control/channels/telegram/bot.rb

@@ -12,9 +12,25 @@ module AgentsControl
       class Bot
         OFFSET_KEY = "telegram:offset"
 
-        # Pause after a network failure: grows toward a ceiling so a
-        # closed laptop doesn't hammer reconnects all night.
-        BACKOFF = [1, 2, 5, 10, 30, 60].freeze
+        # Pause after a network failure. The ceiling is low on purpose:
+        # nothing tells us the network is back, so the pause is how long
+        # the bot stays deaf after a switch between networks — and a
+        # minute of that read as "it froze". A closed laptop is asleep
+        # and doesn't retry at all, so a short ceiling costs nothing there.
+        BACKOFF = [1, 2, 5, 10].freeze
+
+        # A successful poll leaves a timestamp behind, so something
+        # outside this process can tell a bot that is listening from one
+        # that stopped hours ago. `polling?` answers that in-process, and
+        # doctor runs as a separate command — the daemon's port reports
+        # only that it is up, which a deaf daemon is too.
+        HEARTBEAT_KEY = "telegram:last_poll"
+
+        # A healthy poll returns at least every telegram.poll_timeout
+        # (30s), and immediately when something arrives. Writing on each
+        # one would rewrite the store several times a second under
+        # traffic, for a reading nobody needs that finely.
+        HEARTBEAT_EVERY = 15
 
         def initialize(api:, router:, store:, config:, logger: $stdout)
           @api = api
@@ -59,6 +75,12 @@ module AgentsControl
 
         def stop = @stopped&.push(nil)
 
+        # Whether the Telegram side is actually alive. The daemon holds
+        # its port and answers hooks whether or not this thread is
+        # running, so without asking there is no way to tell a bot that
+        # is listening from one that died quietly hours ago.
+        def polling? = @poller&.alive? || false
+
         def running? = @running
 
         private
@@ -69,6 +91,7 @@ module AgentsControl
           while @running
             begin
               poll_once
+              heartbeat
               failures = 0
             rescue Api::Conflict => e
               # Another process is reading updates — looping further is
@@ -86,10 +109,41 @@ module AgentsControl
               failures += 1
               log("API error: #{e.message}")
               pause(backoff(failures))
+            rescue StandardError => e
+              # A backstop, not a place to add expected errors above it.
+              # Whatever it is, the bot going deaf until someone notices
+              # is worse than retrying: the daemon keeps its port and its
+              # hooks either way, so a dead poller looks exactly like a
+              # healthy one from outside.
+              failures += 1
+              log("unexpected #{e.class}: #{redacted(e)}, retrying in #{backoff(failures)}s")
+              pause(backoff(failures))
             end
           end
         end
 
+        # The message may carry the token, so it is only printed once
+        # redaction has actually succeeded — and redaction failing must
+        # not take the handler down with it, which is how the backstop
+        # above managed to kill the very thread it exists to keep alive.
+        def redacted(error)
+          @api.redact(error.message)
+        rescue StandardError
+          "(message withheld — could not redact)"
+        end
+
+        # Best-effort by design: a store that can't be written is not a
+        # reason to stop reading Telegram, which is the whole job.
+        def heartbeat
+          now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          return if @last_heartbeat && now - @last_heartbeat < HEARTBEAT_EVERY
+
+          @last_heartbeat = now
+          @store.put(Time.now.to_i, ttl: 86_400, key: HEARTBEAT_KEY)
+        rescue StandardError => e
+          log("couldn't record the poll heartbeat: #{e.class}")
+        end
+
         def poll_once
           updates = @api.get_updates(offset: offset, timeout: @config.get("telegram.poll_timeout", 30))
 

data/lib/agents_control/channels/telegram/channel.rb

@@ -10,11 +10,19 @@ module AgentsControl
       # because a button physically can't carry more than 64 bytes, and
       # the whole content of an action lives on our side anyway.
       class Channel < Channels::Base
-        def initialize(api:, store:, config:, registry: nil)
+        # Roughly a quarter of an hour in all: long enough to ride out
+        # a switch between networks or a VPN reconnecting, short enough
+        # that a message doesn't turn up hours after it stopped mattering.
+        RESEND_AFTER = [5, 15, 30, 60, 120, 300, 300].freeze
+
+        def initialize(api:, store:, config:, registry: nil,
+                       later: ->(&work) { Thread.new(&work) }, sleeper: ->(seconds) { sleep(seconds) })
           @api = api
           @store = store
           @config = config
           @registry = registry
+          @later = later
+          @sleeper = sleeper
         end
 
         def ready? = !chats.empty?
@@ -56,15 +64,44 @@ module AgentsControl
           chunks = [""] if chunks.empty?
 
           chats.each do |chat_id|
-            chunks.each_with_index do |chunk, i|
-              body = "#{continuation_marker(i, chunks.size)}#{chunk}"
-              sent = send_formatted(chat_id, body, i == chunks.size - 1 ? markup : nil)
-              remember(chat_id, sent, event, question_id) if event
+            stuck = send_chunks(chat_id, chunks, 0, markup, event, question_id)
+            resend_later(chat_id, chunks, stuck, markup, event, question_id) if stuck
+          end
+        end
+
+        # Returns the index of the first chunk the network kept from
+        # going out, or nil once there's nothing left to send.
+        def send_chunks(chat_id, chunks, from, markup, event, question_id)
+          (from...chunks.size).each do |i|
+            body = "#{continuation_marker(i, chunks.size)}#{chunks[i]}"
+            sent = begin
+              send_formatted(chat_id, body, i == chunks.size - 1 ? markup : nil)
+            rescue Api::Unavailable
+              return i
+            end
+            remember(chat_id, sent, event, question_id) if event
+          end
+
+          nil
+        rescue Api::Error
+          # One unreachable chat must not affect the rest, and
+          # definitely must not take down the thread holding the agent.
+          nil
+        end
+
+        # Off the calling thread: that thread is holding the agent's
+        # hook open, and the agent must not sit waiting for the Wi-Fi
+        # to come back. Dropping the message instead is how an agent
+        # that finished during a network switch went unheard of.
+        def resend_later(chat_id, chunks, from, markup, event, question_id)
+          @later.call do
+            RESEND_AFTER.each do |delay|
+              @sleeper.call(delay)
+              from = send_chunks(chat_id, chunks, from, markup, event, question_id)
+              break unless from
             end
-          rescue Api::Error
-            # One unreachable chat must not affect the rest, and
-            # definitely must not take down the thread holding the agent.
-            next
+          rescue StandardError
+            nil
           end
         end
 
@@ -98,9 +135,11 @@ module AgentsControl
           id = sent.is_a?(Hash) ? sent["message_id"] : nil
           return unless id
 
-          @store.put({ "session_id" => event.session_id, "question_id" => question_id,
-                       "cwd" => event.cwd, "label" => event.label },
-                     ttl: REPLY_TARGET_TTL, key: "reply:#{chat_id}:#{id}")
+          target = { "session_id" => event.session_id, "question_id" => question_id,
+                     "cwd" => event.cwd, "label" => event.label }
+          @store.put(target, ttl: REPLY_TARGET_TTL, key: "reply:#{chat_id}:#{id}")
+          # Where a message sent without a reply goes — see the Router.
+          @store.put(target, ttl: REPLY_TARGET_TTL, key: "last:#{chat_id}")
         end
 
         # A short session tag in the header. Needed so that in a chat

data/lib/agents_control/channels/telegram/router.rb

@@ -126,6 +126,10 @@ module AgentsControl
 
           return compose_answer(chat_id, text) if composing?(chat_id) && !text.start_with?("/")
 
+          if !text.empty? && !text.start_with?("/") && (target = @store.get(last_target_key(chat_id)))
+            return answer_target(chat_id, target, text)
+          end
+
           command, argument = text.split(/\s+/, 2)
 
           dispatch(chat_id, command.to_s.sub(/@.*\z/, ""), argument.to_s)
@@ -138,6 +142,10 @@ module AgentsControl
           target = @store.get("reply:#{chat_id}:#{replied['message_id']}")
           return say(chat_id, "I don't remember which session that message was about.") unless target
 
+          answer_target(chat_id, target, text)
+        end
+
+        def answer_target(chat_id, target, text)
           question = target["question_id"]
           return deliver(chat_id, question, Reply.text(text)) if question && @pending&.find(question)
 
@@ -153,19 +161,44 @@ module AgentsControl
         # match wins there if one exists (the common case: replying to
         # an agent's own notification), otherwise any matching tab does
         # (a plain tab mid-interactive-command has no agent to prefer).
+        #
+        # Returns the session it typed into, or nil once it has said why not.
         def type_into_session(chat_id, target, text)
+          session = session_for(chat_id, target)
+          execute(chat_id, session, text, show_result: !session.agent?) if session
+          session
+        end
+
+        def session_for(chat_id, target)
           exact = @registry.refresh.find(target["session_id"])
-          return execute(chat_id, exact, text, show_result: !exact.agent?) if exact && !exact.terminalless?
+          return exact if exact && !exact.terminalless?
 
-          candidates = @registry.sessions.select { |s| s.cwd == target["cwd"] && !s.terminalless? }
-          agent_matches = candidates.select(&:agent?)
-          matching = agent_matches.empty? ? candidates : agent_matches
+          matching = tabs_for(target["cwd"])
 
-          case matching.size
-          when 0 then say(chat_id, "#{target['label']} isn't waiting anymore, and I couldn't find the tab.")
-          when 1 then execute(chat_id, matching.first, text, show_result: !matching.first.agent?)
-          else say(chat_id, "#{target['label']} has several tabs — use /run NUMBER to pick one.")
-          end
+          return matching.first if matching.size == 1
+
+          say(chat_id, if matching.empty?
+                         "#{target['label']} isn't waiting anymore, and I couldn't find the tab."
+                       else
+                         "#{target['label']} has several tabs — use /run NUMBER to pick one."
+                       end)
+          nil
+        end
+
+        # A hook reports the directory the agent is in now, while the
+        # tab and the process only know the one it was started in — so
+        # an agent that cd'd into a subfolder matches no tab exactly.
+        # The agent in the nearest directory above is that same agent;
+        # a plain shell up there is just a neighbour.
+        def tabs_for(cwd)
+          tabs = @registry.sessions.reject(&:terminalless?)
+
+          same = tabs.select { |s| s.cwd == cwd }
+          return same.select(&:agent?).then { |agents| agents.empty? ? same : agents } unless same.empty?
+
+          above = tabs.select { |s| s.agent? && !s.cwd.to_s.empty? && cwd.to_s.start_with?(File.join(s.cwd, "")) }
+          nearest = above.map { |s| s.cwd.length }.max
+          above.select { |s| s.cwd.length == nearest }
         end
 
         # A file from the phone becomes a file on disk, and the agent is
@@ -194,22 +227,50 @@ module AgentsControl
         # ends up pasted into the wrong project.
         def deliver_file(chat_id, message, path)
           caption = message["caption"].to_s.strip
+          album = album_key(chat_id, message)
 
           if (target = caption[%r{\A/run\s+(\d+)}i, 1])
             return with_session(chat_id, target) do |session|
               execute(chat_id, session, with_path(caption.sub(%r{\A/run\s+\d+\s*}i, ""), path),
                       show_result: !session.agent?)
+              remember_album(album, session)
             end
           end
 
           replied = message["reply_to_message"]
           remembered = replied && @store.get("reply:#{chat_id}:#{replied['message_id']}")
-          return type_into_session(chat_id, remembered, with_path(caption, path)) if remembered
+          return remember_album(album, type_into_session(chat_id, remembered, with_path(caption, path))) if remembered
+
+          if (session = album_session(album))
+            return execute(chat_id, session, with_path("", path))
+          end
 
           say(chat_id, "Saved:\n\n`#{path}`\n\nReply to a session's message with a file to hand it " \
                        "straight over, or caption it `/run N`.")
         end
 
+        # Telegram splits an album into one message per file and puts the
+        # caption — and the reply — on only one of them, so the rest
+        # arrive saying nothing about where they go. They go where the
+        # album's caption sent it: sending files together means that.
+        def album_key(chat_id, message)
+          group = message["media_group_id"]
+          group && "album:#{chat_id}:#{group}"
+        end
+
+        # Only an agent gets the rest of the album: a bare path typed
+        # into a shell is a command, not a file handed over.
+        def remember_album(key, session)
+          @store.put(session.id, ttl: 600, key: key) if key && session&.agent?
+          session
+        end
+
+        def album_session(key)
+          id = key && @store.get(key)
+          session = id && @registry.refresh.find(id)
+          session if session&.agent? && !session.terminalless?
+        end
+
         # Escaped, because a name like "quarterly report.csv" is
         # entirely ordinary and an unescaped one arrives at the shell as
         # two arguments. Shellwords leaves a path that needs nothing
@@ -730,10 +791,15 @@ module AgentsControl
           id = sent.is_a?(Hash) ? sent["message_id"] : nil
           return unless id
 
-          @store.put({ "session_id" => session.id, "cwd" => session.cwd, "label" => session.label },
-                     ttl: REPLY_TARGET_TTL, key: "reply:#{chat_id}:#{id}")
+          target = { "session_id" => session.id, "cwd" => session.cwd, "label" => session.label }
+          @store.put(target, ttl: REPLY_TARGET_TTL, key: "reply:#{chat_id}:#{id}")
+          @store.put(target, ttl: REPLY_TARGET_TTL, key: last_target_key(chat_id))
         end
 
+        # Text sent without a reply goes to the session of the last message
+        # the bot sent, so a back-and-forth with one agent needs no replies.
+        def last_target_key(chat_id) = "last:#{chat_id}"
+
         def status(chat_id)
           sessions = @registry.refresh.sessions
           backends = @registry.available_backends.map(&:name).join(", ")

data/lib/agents_control/console.rb

@@ -105,7 +105,7 @@ module AgentsControl
     # The daemon comes up immediately: a console without it is just a
     # window, and the point is to already be connected the moment the tab opens.
     def start_daemon
-      @daemon = Daemon.new(config: @config, store: @store, secrets: @secrets, logger: @out)
+      @daemon = Daemon.new(config: @config, store: @store, secrets: @secrets, logger: daemon_log)
 
       return say("") if @daemon.start
 
@@ -114,6 +114,16 @@ module AgentsControl
       say("")
     end
 
+    # Only puts is ever called on a logger.
+    Interjection = Struct.new(:prompt) do
+      def puts(text = "") = prompt.interject(text)
+    end
+
+    # With a terminal the prompt owns it between commands, so the
+    # daemon's lines go through it; over a pipe there's no raw mode to
+    # work around.
+    def daemon_log = $stdin.tty? ? Interjection.new(editor) : @out
+
     def loop_commands
       while (line = prompt)
         line = line.strip

data/lib/agents_control/doctor.rb

@@ -18,16 +18,17 @@ module AgentsControl
     # control the app.
     NOT_AUTHORISED = "-1743"
 
-    def initialize(config: nil, secrets: nil, executor: Executor.new, api: nil)
+    def initialize(config: nil, secrets: nil, executor: Executor.new, api: nil, store: nil)
       @config = config || Config.load
       @secrets = secrets || Secrets.new
       @executor = executor
       @api = api
+      @store = store
     end
 
     CHECKS = %i[
       ruby_check terminal_check automation_check agent_binary_check
-      token_check chats_check passphrase_check bot_check daemon_check hooks_check
+      token_check chats_check passphrase_check bot_check daemon_check polling_check hooks_check
       anchors_check wake_check
     ].freeze
 
@@ -185,6 +186,36 @@ module AgentsControl
       end
     end
 
+    # The daemon holds its port and answers hooks whether or not it is
+    # still reading Telegram, so "running" and "listening" are separate
+    # questions and only the first was ever asked. A poll loop that died
+    # on a network error looked exactly like a healthy one — for days,
+    # in the case that prompted this.
+    # Derived from the configured long-poll timeout rather than fixed:
+    # a healthy poll returns at least that often, so a hand-raised
+    # telegram.poll_timeout would otherwise make a perfectly good daemon
+    # read as deaf. Two windows plus a minute leaves room for a retry
+    # and the heartbeat's own throttle.
+    def stale_after
+      [(@config.get("telegram.poll_timeout", 30).to_i * 2) + 60, 120].max
+    end
+
+    def polling_check
+      return nil unless daemon_response(@config.get("hooks.port", Daemon::DEFAULT_PORT)) == :ours
+
+      last = store.get(Channels::Telegram::Bot::HEARTBEAT_KEY)
+      return warn("Telegram", "the daemon hasn't reported a poll yet",
+                  "if it persists, restart: agents_control stop && agents_control") unless last
+
+      age = Time.now.to_i - last.to_i
+      return ok("Telegram", "polling — last heard #{age}s ago") if age < stale_after
+
+      fail("Telegram", "the daemon is up but hasn't polled for #{age / 60} min — messages aren't arriving",
+           "agents_control stop && agents_control")
+    end
+
+    def store = @store ||= Store.new
+
     def daemon_response(port)
       socket = Socket.tcp("127.0.0.1", port, connect_timeout: 1)
       socket.print("POST /ping HTTP/1.1\r\nHost: localhost\r\nContent-Length: 2\r\n\r\n{}")

data/lib/agents_control/inbox.rb

@@ -57,10 +57,17 @@ module AgentsControl
 
     class TooLarge < StandardError; end
 
-    def initialize(api:, dir: self.class.path, keep_days: 14)
+    # Seconds between attempts. A dropped connection on a phone's
+    # network or a reconnecting VPN is gone again within seconds, and
+    # the alternative is asking someone away from home to send the
+    # file again.
+    RETRY_AFTER = [1, 3, 5].freeze
+
+    def initialize(api:, dir: self.class.path, keep_days: 14, sleeper: ->(seconds) { sleep(seconds) })
       @api = api
       @dir = dir
       @keep_days = keep_days
+      @sleeper = sleeper
     end
 
     # The local path the file landed at.
@@ -68,17 +75,32 @@ module AgentsControl
       size = attachment.file_size.to_i
       raise TooLarge, "#{human(size)} is over the #{human(MAX_BYTES)} Telegram allows a bot to download" if size > MAX_BYTES
 
-      remote = @api.file_path_for(attachment.file_id)
-      prepare
-      destination = File.join(@dir, name_for(attachment, remote))
+      retrying do
+        remote = @api.file_path_for(attachment.file_id)
+        prepare
+        destination = File.join(@dir, name_for(attachment, remote))
 
-      download(remote, destination)
-      prune
-      destination
+        download(remote, destination)
+        prune
+        destination
+      end
     end
 
     private
 
+    def retrying
+      attempt = 0
+      begin
+        yield
+      rescue Channels::Telegram::Api::Unavailable
+        raise if attempt >= RETRY_AFTER.size
+
+        @sleeper.call(RETRY_AFTER[attempt])
+        attempt += 1
+        retry
+      end
+    end
+
     # Downloaded beside the destination and renamed into place: a
     # connection that drops half way through otherwise leaves a
     # truncated file with a name that promises a whole one, and the

data/lib/agents_control/process_probe.rb

@@ -27,7 +27,12 @@ module AgentsControl
       # i.e. what the user is currently interacting with.
       def foreground? = stat.to_s.include?("+")
       def name = File.basename(command.to_s)
-      def agent = AGENT_BINARIES[name]
+
+      # Claude Code retitles its own process to `Claude` partway through
+      # a long session, so an exact match loses the tab. The desktop app
+      # is also called `Claude`, but it never has a terminal — that's
+      # what keeps it from passing for an agent here.
+      def agent = AGENT_BINARIES[name] || (terminal? ? AGENT_BINARIES[name.downcase] : nil)
       def agent? = !agent.nil?
       def terminal? = tty != NO_TTY
     end
@@ -37,10 +42,13 @@ module AgentsControl
     end
 
     # Re-reads the process tree. The result is cached on the object — one
-    # probe per registry pass.
+    # probe per registry pass. The per-tab index is derived from it, so it
+    # has to be dropped here too: a long-lived daemon would otherwise keep
+    # answering from the first snapshot it ever took.
     def refresh
       result = @executor.run(Which.find!("ps"), "-A", "-o", "tty=,pid=,stat=,comm=")
       @processes = result.success? ? parse(result.stdout) : []
+      @by_tty = nil
       self
     end
 

data/lib/agents_control/prompt.rb

@@ -19,6 +19,23 @@ module AgentsControl
       @completer = completer || ->(_word) { [] }
       @describer = describer || ->(_item) { nil }
       @history = []
+      # Reentrant: interject redraws the line, and so does every keystroke.
+      @lock = Monitor.new
+    end
+
+    # A line from another thread — the daemon logs while someone types.
+    # Raw mode turns off the terminal's own "\n" → "\r\n", so printed
+    # as-is every line started where the previous one ended and landed
+    # on top of the line being typed. It goes above that line instead,
+    # and the line is drawn again underneath.
+    def interject(text)
+      @lock.synchronize do
+        return @out.puts(text) unless @reading
+
+        erase_drawn
+        @out.print("#{text.to_s.chomp.gsub("\n", "\r\n")}\r\n")
+        render
+      end
     end
 
     # Returns the entered line, or nil if input closed (Ctrl-D).
@@ -32,12 +49,25 @@ module AgentsControl
       @history_at = @history.size
       @result = nil
 
-      render
-      @in.raw { loop { break if handle(read_key) == :done } }
+      @lock.synchronize do
+        render
+        @reading = true
+      end
+      # The key is read outside the lock: waiting for one must not hold
+      # back a log line.
+      @in.raw do
+        loop do
+          key = read_key
+          break if @lock.synchronize { handle(key) } == :done
+        end
+      end
 
       @result
     ensure
-      finish
+      @lock.synchronize do
+        @reading = false
+        finish
+      end
     end
 
     private

data/lib/agents_control/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AgentsControl
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/agents_control.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "io/console"
+require "monitor"
 require "shellwords"
 
 # The base error is declared before the other files: error classes

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: agents_control
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Sapar Kurmanov