agents_control 0.2.0 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b71d165050803893091b3bce0857cb4a9cac7875e28289e0aaebc6bf4a1aa820
-  data.tar.gz: a301e0e972625e0eb57a79e80799e21edf2232d24ef8bbbfb74840484d1feb7e
+  metadata.gz: aadeb50868f7e15b7da9346e051f268ffad1c652c1e7297d54cb328380b030f6
+  data.tar.gz: cf62c6519dfd54bb7b9ee169c5e1b58f5bcf92b54993e5a61e954547180b6ec2
 SHA512:
-  metadata.gz: b6a5dd4eb521026c1084ade954fbe7d7a8f26426e3d68d78077a3d69e71addc0c40165181eaaff963a225434a71167e0ed02f68382fe8ed4605a46f8e781bc54
-  data.tar.gz: 7077e2aa298e86630f4c619e67a6bde0be85a2316f86c43b46dbd354353bc9404f91a0db8aa86ab9f8fcf1f0c3d6e8cee101c1b55cbf53080810f52d2ba37df1
+  metadata.gz: dce0f05882260d26dddc1a65f392ef0cf8ad7351b1ccbd07e29d2378c2871077434669e4f3c7248b682fd10aa72aedbfbbfae5739703222040bd3741e9a2be4a
+  data.tar.gz: f3e61a373a6252b920e6086b9e9b01591855fecc8708ffd059e0f87d412fce749d97cc445a6553aa42d69e404c60973ab1eb6551c2db60ae3362cce2756964f7

data/README.md

@@ -104,20 +104,35 @@ Bot commands:
 
 The number `N` comes from the last list shown.
 
-`/run` treats the command itself as the reference point: the shell
-echoes back whatever's typed, so it looks for that exact text on
-screen and shows from there — sharper than diffing screenshots, and
-it still works even if something else wrote to the same tab in
-between, since it doesn't need the screen from right before typing to
-relate to the screen after at all. A short reply ("y", "n" mid `git
-add -p`) isn't a safe anchor on its own — too likely to match
-something unrelated — so those fall back to a before/after diff
-instead, and when even that can't cleanly tell what's new, to the
-current screen outright: seeing the result, possibly with a little
-stale context around it, beats not seeing it at all. How much gets
-captured either way is a `/settings` option (`terminal.run_result_lines`,
-200 by default) — a command whose output runs longer just gets its
-last N lines, same as the default gets cut by a screen that's too tall.
+Against a plain tab, `/run` treats the command itself as the reference
+point: the shell echoes back whatever's typed, so it looks for that
+exact text on screen and shows from there — sharper than diffing
+screenshots, and it still works even if something else wrote to the
+same tab in between, since it doesn't need the screen from right
+before typing to relate to the screen after at all. A short reply
+("y", "n" mid `git add -p`) isn't a safe anchor on its own — too
+likely to match something unrelated — so those fall back to a
+before/after diff instead, and when even that can't cleanly tell
+what's new, to the current screen outright: seeing the result,
+possibly with a little stale context around it, beats not seeing it
+at all. How much gets captured either way is a `/settings` option
+(`terminal.run_result_lines`, 200 by default) — a command whose output
+runs longer just gets its last N lines, same as the default gets cut
+by a screen that's too tall.
+
+Against an agent, `/run` just confirms the send — an agent isn't a
+shell command that finishes in a couple of seconds, so there's no
+"result" to capture yet by the time it would look. Hooks already own
+telling Telegram when it's actually done or needs something, the same
+as replying to one of its own questions.
+
+A tab stuck inside `less`, `vim`, a REPL, or anything else that reads
+keystrokes as its own input rather than a line to submit gets a
+confirmation first instead of a blind send — the text would go to
+whatever's actually running there, not run as a command. A pager not
+on that recognized list still gets caught: a bare `:` as the entire
+last line is the one thing practically every pager agrees on for
+"waiting on you," and a real shell prompt never looks like that.
 
 The result stays a live target: replying to it — "y", "n", anything —
 types straight into that same pane and shows what came back, so

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

@@ -14,6 +14,18 @@ module AgentsControl
         # they get a separate confirmation.
         REMOTE_COMMANDS = %w[ssh mosh].freeze
 
+        # Programs that read keystrokes as their own input, not as a
+        # line to submit to a shell. Sending a command into one of
+        # these wouldn't run it — it'd feed the letters to whatever's
+        # already there instead: pager navigation, an editor's insert
+        # mode, a REPL evaluating each character-by-character. Confirmed
+        # against a real incident: `git log`'s pager was still open,
+        # "git status" went in as keystrokes, and nothing about it ran
+        # as a command at all.
+        INTERACTIVE_COMMANDS = %w[less more most vim vi nvim emacs nano pico
+                                   man top htop irb pry python python3 node
+                                   mysql psql sqlite3].freeze
+
         # Shared list for the Telegram menu and for /help: a menu that's
         # drifted from reality is worse than no menu. The third element
         # is the argument syntax, needed only in /help; setMyCommands
@@ -196,11 +208,29 @@ module AgentsControl
 
           with_session(chat_id, number) do |session|
             next say(chat_id, "This session has no terminal — nothing to run there.") if session.terminalless?
-
-            if remote?(session)
-              confirm_remote(chat_id, session, command)
+            next confirm_remote(chat_id, session, command) if remote?(session)
+
+            # An agent isn't a shell command that finishes in a couple
+            # of seconds — it's a real task, and hooks already own
+            # telling Telegram when it's actually done or needs
+            # something. Capturing a "result" a moment after typing
+            # would just catch it mid-thought and fall back to dumping
+            # its whole transcript, which isn't a result at all — same
+            # reasoning as replying to an agent's own question
+            # (type_into_session).
+            next execute(chat_id, session, command, show_result: false) if session.agent?
+            next confirm_interactive(chat_id, session, command) if interactive?(session)
+
+            # One capture serves two purposes: it's checked for a
+            # pager's bare `:` prompt right here, and reused as
+            # execute()'s own "before" snapshot if it turns out clean —
+            # capturing twice would desync anything that reads the
+            # screen expecting to see it change between calls.
+            before = capture_screen(session, lines: run_result_lines)
+            if paused_for_input?(before)
+              confirm_interactive(chat_id, session, command)
             else
-              execute(chat_id, session, command, show_result: true)
+              execute(chat_id, session, command, show_result: true, before: before)
             end
           end
         end
@@ -211,6 +241,21 @@ module AgentsControl
           REMOTE_COMMANDS.include?(session.foreground_command.to_s)
         end
 
+        def interactive?(session)
+          INTERACTIVE_COMMANDS.include?(session.foreground_command.to_s)
+        end
+
+        # Backstop for interactive? missing a pager by name — a custom
+        # $PAGER, or anything else not on that list. A bare `:` as the
+        # entire last line is the one thing practically every pager in
+        # the less/more lineage agrees on for "waiting on you"; a real
+        # shell prompt always has more on that line than a single
+        # colon. Takes the screen rather than the session so the
+        # caller's own capture can be reused instead of taking another.
+        def paused_for_input?(screen)
+          screen.to_s.rstrip.lines.last.to_s.strip == ":"
+        end
+
         def confirm_remote(chat_id, session, command)
           key = @store.put({ "action" => "run", "session_id" => session.id, "text" => command },
                            ttl: 300)
@@ -225,6 +270,21 @@ module AgentsControl
               markup: markup)
         end
 
+        def confirm_interactive(chat_id, session, command)
+          key = @store.put({ "action" => "run", "session_id" => session.id, "text" => command },
+                           ttl: 300)
+
+          markup = { inline_keyboard: [[
+            { text: "⚠️ Send anyway", callback_data: key },
+            { text: "cancel", callback_data: @store.put({ "action" => "cancel" }, ttl: 300) }
+          ]] }
+
+          say(chat_id, "#{session.label} is inside #{session.foreground_command} right now, " \
+                       "not at a shell prompt — the text would go to that, not run as a command:\n\n" \
+                       "`#{command}`",
+              markup: markup)
+        end
+
         # Enter is sent as a separate call, not tacked onto the same
         # input: a merged call can fail to send multi-line text at all.
         TYPING_PAUSE = 0.4
@@ -241,9 +301,9 @@ module AgentsControl
 
         def run_result_lines = @config.get("terminal.run_result_lines", 200)
 
-        def execute(chat_id, session, command, show_result: false)
+        def execute(chat_id, session, command, show_result: false, before: nil)
           backend = @registry.backend_for(session)
-          before = show_result ? capture_screen(session, lines: run_result_lines) : nil
+          before ||= capture_screen(session, lines: run_result_lines) if show_result
 
           ok = backend.send_text(session.id, command, newline: false) &&
                sleep(TYPING_PAUSE).then { backend.send_text(session.id, "", newline: true) }
@@ -514,7 +574,7 @@ module AgentsControl
           case payload["action"]
           when "focus" then focus_session(chat_id, session)
           when "screen" then show_screen(chat_id, session)
-          when "run" then execute(chat_id, session, payload["text"], show_result: true)
+          when "run" then execute(chat_id, session, payload["text"], show_result: !session.agent?)
           when "close_confirm" then say(chat_id, "Close #{session.label}?",
                                         markup: @keyboards.confirm("close", session))
           when "close" then close_session(chat_id, session)

data/lib/agents_control/version.rb

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

metadata

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