octo-agent 0.11.2

data/lib/octo/server/channel.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# Channel layer — bridges Server Sessions to IM platforms (Feishu, WeCom, etc.)
+#
+# Load order:
+#   1. Adapter base & registry
+#   2. Platform adapters (each self-registers via Adapters.register)
+#   3. ChannelConfig (IM platform credentials)
+#   4. ChannelUIController (UIInterface impl that sends to IM)
+#   5. ChannelManager (orchestrates adapters + sessions, in-memory session map)
+#
+# Usage in HttpServer:
+#   require_relative "channel"
+#   @channel_manager = Octo::Channel::ChannelManager.new(
+#     session_registry: @registry,
+#     session_builder:  method(:build_session),
+#     channel_config:   Octo::ChannelConfig.load
+#   )
+#   @channel_manager.start
+
+require_relative "channel/adapters/base"
+
+# Load platform adapters (each registers itself)
+require_relative "channel/adapters/feishu/adapter"
+require_relative "channel/adapters/wecom/adapter"
+require_relative "channel/adapters/weixin/adapter"
+require_relative "channel/adapters/discord/adapter"
+require_relative "channel/adapters/telegram/adapter"
+require_relative "channel/adapters/dingtalk/adapter"
+
+require_relative "channel/channel_config"
+require_relative "channel/channel_ui_controller"
+require_relative "channel/channel_manager"

data/lib/octo/server/discover.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+require "socket"
+
+module Octo
+  module Server
+    # Discover locally-running Octo server(s) by scanning PID files
+    # written by Master at /tmp/octo-master-<port>.pid.
+    #
+    # Used by the CLI (bare `octo agent` mode) to auto-detect a sibling
+    # server process, so skills that call back into the server (channels,
+    # browser, scheduler, etc.) can work without the user manually setting
+    # OCTO_SERVER_HOST / OCTO_SERVER_PORT.
+    #
+    # Fast and side-effect free: only reads files and sends signal 0.
+    # Does NOT probe the TCP port (avoids false positives from stale files
+    # but also avoids noisy connection attempts).
+    module Discover
+      PID_FILE_GLOB = File.join(Dir.tmpdir, "octo-master-*.pid").freeze
+      PID_FILE_REGEX = /octo-master-(\d+)\.pid\z/.freeze
+
+      module_function
+
+      # Find the first live Octo server on this machine.
+      #
+      # @return [Hash, nil] { host: "127.0.0.1", port: Integer, pid: Integer } or nil
+      def find_local
+        find_all_local.first
+      end
+
+      # Find all live Octo servers on this machine.
+      #
+      # A PID file is considered "live" when:
+      #   1. The filename matches octo-master-<port>.pid
+      #   2. Its contents parse as a positive integer
+      #   3. Process.kill(0, pid) confirms the PID is alive
+      #
+      # Stale PID files (process gone) are silently ignored. We do NOT
+      # delete them here — that's the owning server's responsibility.
+      #
+      # @return [Array<Hash>] sorted by port ascending
+      def find_all_local
+        Dir.glob(PID_FILE_GLOB).filter_map do |path|
+          m = path.match(PID_FILE_REGEX)
+          next nil unless m
+
+          port = m[1].to_i
+          next nil if port <= 0
+
+          pid_str = File.read(path).strip rescue nil
+          next nil if pid_str.nil? || pid_str.empty?
+
+          pid = pid_str.to_i
+          next nil if pid <= 0
+
+          next nil unless process_alive?(pid)
+
+          { host: "127.0.0.1", port: port, pid: pid }
+        end.sort_by { |e| e[:port] }
+      end
+
+      # @param pid [Integer]
+      # @return [Boolean]
+      def process_alive?(pid)
+        Process.kill(0, pid)
+        true
+      rescue Errno::ESRCH, Errno::EPERM
+        # ESRCH — no such process; EPERM — process exists but owned by someone else
+        # (still technically alive, but we can't safely assume it's "our" server)
+        false
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

data/lib/octo/server/epipe_safe_io.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module Octo
+  module Server
+    # EPIPESafeIO — wraps an IO ($stdout / $stderr) so that writes never raise
+    # Errno::EPIPE / IOError to the calling code.
+    #
+    # Why this exists:
+    #   The server worker process inherits fd 0/1/2 from the Master. If the
+    #   Master itself was launched in a way where its stdout/stderr eventually
+    #   becomes a broken pipe (e.g. launched by an installer that exits, or by
+    #   a GUI/IDE process that closes its end), the worker's first `puts` after
+    #   that pipe breaks raises Errno::EPIPE. Unhandled, this kills the worker
+    #   — taking all in-memory sessions, agent loops, and SSE connections down
+    #   with it, and triggering a crash loop because the new worker inherits
+    #   the same broken fd.
+    #
+    # Behavior:
+    #   - Healthy state: delegates every method to the underlying IO. Users
+    #     see normal terminal output (banner, request logs, etc.).
+    #   - First broken-pipe failure: catches Errno::EPIPE / IOError, swaps
+    #     the underlying IO to /dev/null permanently, and returns silently.
+    #     Subsequent writes succeed (into /dev/null) so the worker stays alive.
+    #   - Session state, agent loops, SSE connections all preserved.
+    #
+    # Scope:
+    #   We only wrap $stdout / $stderr (the global variables that Kernel#puts,
+    #   Kernel#print, Kernel#warn, etc. use under the hood). We do NOT touch
+    #   the STDOUT / STDERR constants — a codebase audit confirmed nothing in
+    #   Octo writes to those constants directly (only `STDOUT.flush` which
+    #   cannot raise EPIPE).
+    class EPIPESafeIO < SimpleDelegator
+      # Methods that perform writes and may raise Errno::EPIPE.
+      # We override each one to rescue and degrade gracefully.
+      WRITE_METHODS = %i[write write_nonblock syswrite puts print printf << putc].freeze
+
+      WRITE_METHODS.each do |m|
+        define_method(m) do |*args, **kwargs, &blk|
+          if kwargs.empty?
+            __getobj__.public_send(m, *args, &blk)
+          else
+            __getobj__.public_send(m, *args, **kwargs, &blk)
+          end
+        rescue Errno::EPIPE, IOError => e
+          fall_back_to_null!(e)
+          # Retry the write into /dev/null so semantics (return value type) stay
+          # close to what the caller expects. If even this fails, swallow it —
+          # we must not raise from inside a write to $stdout/$stderr.
+          begin
+            if kwargs.empty?
+              __getobj__.public_send(m, *args, &blk)
+            else
+              __getobj__.public_send(m, *args, **kwargs, &blk)
+            end
+          rescue StandardError
+            nil
+          end
+        end
+      end
+
+      # Some callers do `$stdout.flush`. Make it safe too.
+      def flush
+        __getobj__.flush
+      rescue Errno::EPIPE, IOError => e
+        fall_back_to_null!(e)
+        nil
+      end
+
+      # Whether this wrapper has already fallen back to /dev/null.
+      # Useful for tests and diagnostics.
+      def fell_back?
+        @fell_back == true
+      end
+
+      private def fall_back_to_null!(error)
+        return if @fell_back
+
+        @fell_back = true
+        begin
+          # Best-effort: try to log once via Octo::Logger if available.
+          # Wrapped in rescue because Logger itself might be mid-init.
+          if defined?(Octo::Logger)
+            Octo::Logger.warn(
+              "[EPIPESafeIO] Underlying IO broken (#{error.class}: #{error.message}); " \
+              "falling back to /dev/null. Worker stays alive."
+            )
+          end
+        rescue StandardError
+          # ignore
+        end
+
+        begin
+          null = File.open(File::NULL, "w")
+          null.sync = true
+          __setobj__(null)
+        rescue StandardError
+          # If even opening /dev/null fails, leave the original object — at
+          # worst the next write raises again and we rescue again.
+        end
+      end
+    end
+  end
+end