octo-agent 0.11.2

data/lib/octo/server/scheduler.rb

@@ -0,0 +1,317 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module Octo
+  module Server
+    # Scheduler reads ~/.octo/schedules.yml and runs tasks on a cron-like schedule.
+    #
+    # It starts a background thread that ticks every 60 seconds, checks all
+    # configured schedules, and fires any task whose cron expression matches
+    # the current time.
+    #
+    # Schedule file format (~/.octo/schedules.yml):
+    #
+    #   - name: daily_report
+    #     task: daily_report          # references ~/.octo/tasks/daily_report.md
+    #     cron: "0 9 * * 1-5"        # standard 5-field cron expression
+    #     enabled: true               # optional, defaults to true
+    #
+    # Cron field order: minute hour day-of-month month day-of-week
+    class Scheduler
+      SCHEDULES_FILE = File.expand_path("~/.octo/schedules.yml")
+      TASKS_DIR      = File.expand_path("~/.octo/tasks")
+
+      def initialize(session_registry:, session_builder:, task_runner:)
+        @registry        = session_registry
+        @session_builder = session_builder  # callable: (name:, working_dir:) -> session_id
+        # Callable that runs a task on an agent with unified status/save/broadcast
+        # handling — signature: (session_id, agent, &block). Same contract as
+        # the one ChannelManager receives.
+        @task_runner     = task_runner
+        @thread          = nil
+        @running         = false
+        @mutex           = Mutex.new
+      end
+
+      # Start the background scheduler thread.
+      def start
+        @mutex.synchronize do
+          return if @running
+
+          @running = true
+          @thread  = Thread.new { run_loop }
+          @thread.name = "octo-scheduler"
+        end
+      end
+
+      # Stop the background scheduler thread gracefully.
+      # NOTE: intentionally avoids Mutex here so it is safe to call from a
+      # signal trap context (Ruby disallows Mutex#synchronize inside traps).
+      def stop
+        @running = false
+        @thread&.wakeup rescue nil
+        @thread&.join(5)
+      end
+
+      def running?
+        @running
+      end
+
+      # Return all schedules from the config file.
+      def schedules
+        load_schedules
+      end
+
+      # ── Schedule CRUD ────────────────────────────────────────────────────────
+
+      # Add or update a schedule entry in schedules.yml.
+      def add_schedule(name:, task:, cron:, enabled: true)
+        list = load_schedules
+        # Remove existing entry with the same name
+        list.reject! { |s| s["name"] == name }
+        list << {
+          "name"    => name,
+          "task"    => task,
+          "cron"    => cron,
+          "enabled" => enabled
+        }
+        save_schedules(list)
+      end
+
+      # Remove a schedule entry by name.
+      def remove_schedule(name)
+        list = load_schedules
+        before_count = list.size
+        list.reject! { |s| s["name"] == name }
+        save_schedules(list)
+        list.size < before_count
+      end
+
+      # Update an existing schedule entry (cron and/or enabled).
+      # Returns false if the schedule does not exist.
+      def update_schedule(name, cron: nil, enabled: nil)
+        list = load_schedules
+        entry = list.find { |s| s["name"] == name }
+        return false unless entry
+
+        entry["cron"]    = cron    unless cron.nil?
+        entry["enabled"] = enabled unless enabled.nil?
+        save_schedules(list)
+        true
+      end
+
+      # ── Composite cron-task helpers ──────────────────────────────────────────
+
+      # Create a task file and its schedule in one step.
+      def create_cron_task(name:, content:, cron:, enabled: true)
+        write_task(name, content)
+        add_schedule(name: name, task: name, cron: cron, enabled: enabled)
+      end
+
+      # Update a cron-task: optionally update content and/or schedule fields.
+      def update_cron_task(name, content: nil, cron: nil, enabled: nil)
+        raise "Cron task not found: #{name}" unless list_tasks.include?(name)
+
+        write_task(name, content) unless content.nil?
+        update_schedule(name, cron: cron, enabled: enabled) if cron || !enabled.nil?
+      end
+
+      # Delete a cron-task: remove both the task file and its schedule.
+      def delete_cron_task(name)
+        removed_schedule = remove_schedule(name)
+        removed_task     = delete_task(name)
+        removed_schedule || removed_task
+      end
+
+      # Return a merged list of cron-tasks (task content + schedule metadata).
+      def list_cron_tasks
+        schedule_map = load_schedules.each_with_object({}) do |s, h|
+          h[s["task"]] = s if s.is_a?(Hash)
+        end
+
+        list_tasks.map do |task_name|
+          content  = begin; read_task(task_name); rescue StandardError; ""; end
+          schedule = schedule_map[task_name] || {}
+          {
+            "name"    => task_name,
+            "content" => content,
+            "cron"    => schedule["cron"],
+            "enabled" => schedule.fetch("enabled", true),
+            "scheduled" => !schedule.empty?
+          }
+        end
+      end
+
+      # ── Task file helpers ────────────────────────────────────────────────────
+
+      # Read the prompt content of a named task.
+      def read_task(task_name)
+        path = task_file_path(task_name)
+        raise "Task not found: #{task_name} (expected #{path})" unless File.exist?(path)
+
+        File.read(path)
+      end
+
+      # Write the prompt content for a named task.
+      def write_task(task_name, content)
+        FileUtils.mkdir_p(TASKS_DIR)
+        File.write(task_file_path(task_name), content)
+      end
+
+      # List all existing task names.
+      def list_tasks
+        return [] unless Dir.exist?(TASKS_DIR)
+
+        Dir.glob(File.join(TASKS_DIR, "*.md")).map do |path|
+          File.basename(path, ".md")
+        end.sort
+      end
+
+      # Delete a task file and remove all schedules that reference it.
+      # Returns true if the task file existed and was deleted, false otherwise.
+      def delete_task(task_name)
+        path = task_file_path(task_name)
+        return false unless File.exist?(path)
+
+        File.delete(path)
+        # Remove all schedules referencing this task
+        load_schedules.select { |s| s["task"] == task_name }.each do |s|
+          remove_schedule(s["name"])
+        end
+        true
+      end
+
+      # Return the file path for a task.
+      def task_file_path(task_name)
+        File.join(TASKS_DIR, "#{task_name}.md")
+      end
+
+      # ── Internal ─────────────────────────────────────────────────────────────
+
+      private def run_loop
+        loop do
+          break unless @running
+
+          tick(Time.now)
+
+          # Sleep until the start of the next minute
+          now     = Time.now
+          sleep_s = 60 - now.sec
+          sleep(sleep_s)
+        end
+      rescue => e
+        Octo::Logger.error("scheduler_fatal_error", error: e)
+      end
+
+      # Check all enabled schedules against the given time and fire matching ones.
+      private def tick(now)
+        load_schedules.each do |schedule|
+          next unless schedule["enabled"] != false
+          next unless cron_matches?(schedule["cron"].to_s, now)
+
+          fire_task(schedule)
+        rescue => e
+          Octo::Logger.error("scheduler_tick_error", schedule: schedule["name"], error: e)
+        end
+      end
+
+      # Execute a scheduled task by creating a new agent session.
+      private def fire_task(schedule)
+        task_name = schedule["task"].to_s
+        prompt    = read_task(task_name)
+        name      = "⏰ #{schedule["name"]} #{Time.now.strftime("%H:%M")}"
+
+        working_dir = File.expand_path("~/octo_workspace")
+        FileUtils.mkdir_p(working_dir)
+
+        # Scheduled tasks run unattended — use auto_approve so request_user_feedback doesn't block.
+        session_id = @session_builder.call(name: name, working_dir: working_dir, permission_mode: :auto_approve, source: :cron)
+
+        Octo::Logger.info("scheduler_task_fired", task: task_name, session: session_id)
+
+        agent = nil
+        @registry.with_session(session_id) { |s| agent = s[:agent] }
+        return unless agent
+
+        # Delegate to the unified task runner (same code path as manual runs and
+        # channel-triggered runs). It handles:
+        #   * status transitions (:running → :idle/:error)
+        #   * broadcasting session_update
+        #   * persisting the session JSON on success/interrupted/error   ← the bit we were missing
+        #   * idle-compression timer lifecycle
+        @task_runner.call(session_id, agent) { agent.run(prompt) }
+
+        Octo::Logger.info("scheduler_task_dispatched", task: task_name, session: session_id)
+      rescue => e
+        Octo::Logger.error("scheduler_fire_error", task: schedule["task"], error: e)
+      end
+
+      # ── Cron parsing ─────────────────────────────────────────────────────────
+
+      # Returns true if the 5-field cron expression matches the given Time.
+      # Fields: minute hour day-of-month month day-of-week
+      private def cron_matches?(expr, time)
+        fields = expr.strip.split(/\s+/)
+        return false unless fields.size == 5
+
+        minute, hour, dom, month, dow = fields
+
+        cron_field_matches?(minute, time.min)   &&
+          cron_field_matches?(hour,   time.hour)  &&
+          cron_field_matches?(dom,    time.day)   &&
+          cron_field_matches?(month,  time.month) &&
+          cron_field_matches?(dow,    time.wday)
+      end
+
+      # Match a single cron field value against the actual time value.
+      # Supports: * (any), */n (step), n-m (range), n-m/s (range with step),
+      #           and comma-separated lists of the above.
+      private def cron_field_matches?(field, value)
+        field.split(",").any? { |part| cron_part_matches?(part.strip, value) }
+      end
+
+      private def cron_part_matches?(part, value)
+        if part == "*"
+          true
+        elsif part.include?("/")
+          base, step = part.split("/")
+          step = step.to_i
+          return false if step.zero?
+
+          if base == "*"
+            (value % step).zero?
+          else
+            min, max = base.split("-").map(&:to_i)
+            max ||= value
+            value.between?(min, max) && ((value - min) % step).zero?
+          end
+        elsif part.include?("-")
+          min, max = part.split("-").map(&:to_i)
+          value.between?(min, max)
+        else
+          part.to_i == value
+        end
+      end
+
+      # ── File I/O ─────────────────────────────────────────────────────────────
+
+      private def load_schedules
+        return [] unless File.exist?(SCHEDULES_FILE)
+
+        data = YAMLCompat.load_file(SCHEDULES_FILE, permitted_classes: [Symbol])
+        raw  = data.is_a?(Hash) ? data["schedules"] : data
+        Array(raw).select { |s| s.is_a?(Hash) }
+      rescue => e
+        Octo::Logger.error("scheduler_load_schedules_error", error: e)
+        []
+      end
+
+      private def save_schedules(list)
+        FileUtils.mkdir_p(File.dirname(SCHEDULES_FILE))
+        File.write(SCHEDULES_FILE, YAML.dump(list))
+      end
+    end
+  end
+end

data/lib/octo/server/server_master.rb

@@ -0,0 +1,325 @@
+# frozen_string_literal: true
+
+require "socket"
+require "tmpdir"
+require_relative "../banner"
+require_relative "../version"
+
+module Octo
+  module Server
+    # Master process — owns the listen socket, spawns/monitors worker processes.
+    #
+    # Lifecycle:
+    #   octo server
+    #     └─ Master.run  (this file)
+    #           ├─ creates TCPServer, holds it forever
+    #           ├─ spawns Worker via spawn() — full new Ruby process, loads fresh gem
+    #           ├─ traps USR1 → hot_restart (spawn new worker, gracefully stop old)
+    #           └─ traps TERM/INT → shutdown (stop worker, exit cleanly)
+    #
+    # Worker receives:
+    #   OCTO_WORKER=1          — "I am a worker, start HttpServer directly"
+    #   OCTO_INHERIT_FD=<n>   — file descriptor number of the inherited TCPServer socket
+    #   OCTO_MASTER_PID=<n>   — master PID so worker can send USR1 back on upgrade
+    class Master
+      # Worker exits with this code to request a hot restart (e.g. after gem upgrade).
+      RESTART_EXIT_CODE        = 75
+      MAX_CONSECUTIVE_FAILURES = 5
+
+      def initialize(host:, port:, argv: nil, extra_flags: [])
+        @host   = host
+        @port   = port
+        @argv   = argv          # kept for backward compat but no longer used
+        @extra_flags = extra_flags
+
+        @socket     = nil
+        @worker_pid = nil
+        @restart_requested = false
+        @shutdown_requested = false
+      end
+
+      def run
+        # 0. Kill any existing master on this port before binding.
+        kill_existing_master
+
+        # 1. Try to bind the socket.
+        # If port is 8888 (default), try fallback ports 8889-8893 if occupied.
+        # If port is non-default (user-specified), only try that exact port.
+        original_port = @port
+        max_port = (@port == 8888) ? (@port + 5) : @port
+        @socket = bind_with_fallback(@host, @port, max_port: max_port)
+        
+        if @socket.nil?
+          if @port == 8888
+            Octo::Logger.error("[Master] No available ports in range 8888-8893")
+          else
+            Octo::Logger.error("[Master] Port #{@port} is in use")
+          end
+          exit(1)
+        end
+        
+        @socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
+        @port = @socket.local_address.ip_port  # Update to actual bound port
+
+        # 2. Print banner after port is determined
+        print_banner(port_changed: @port != original_port, original_port: original_port)
+
+        write_pid_file
+
+        # 3. Signal handlers
+        Signal.trap("USR1") { @restart_requested  = true }
+        Signal.trap("TERM") { @shutdown_requested = true }
+        Signal.trap("INT")  { @shutdown_requested = true }
+        Signal.trap("HUP")  { @shutdown_requested = true }
+
+        # 4. Spawn first worker
+        @worker_pid = spawn_worker
+        @consecutive_failures = 0
+
+        # 4. Monitor loop
+        loop do
+          if @shutdown_requested
+            shutdown
+            break
+          end
+
+          if @restart_requested
+            @restart_requested = false
+            hot_restart
+            @consecutive_failures = 0
+          end
+
+          # Non-blocking wait: check if worker has exited
+          pid, status = Process.waitpid2(@worker_pid, Process::WNOHANG)
+          if pid
+            exit_code = status.exitstatus
+            if exit_code == RESTART_EXIT_CODE
+              Octo::Logger.info("[Master] Worker requested restart (exit #{RESTART_EXIT_CODE}).")
+              @worker_pid = spawn_worker
+              @consecutive_failures = 0
+            elsif @shutdown_requested
+              break
+            else
+              @consecutive_failures += 1
+              if @consecutive_failures >= MAX_CONSECUTIVE_FAILURES
+                Octo::Logger.error("[Master] Worker failed #{MAX_CONSECUTIVE_FAILURES} times in a row, giving up.")
+                shutdown
+                break
+              end
+              delay = [0.5 * (2 ** (@consecutive_failures - 1)), 30].min  # exponential backoff, max 30s
+              Octo::Logger.warn("[Master] Worker exited unexpectedly (exit #{exit_code}), failure #{@consecutive_failures}/#{MAX_CONSECUTIVE_FAILURES}, restarting in #{delay}s...")
+              sleep delay
+              @worker_pid = spawn_worker
+            end
+          end
+
+          sleep 0.1
+        end
+      ensure
+        remove_pid_file
+      end
+
+
+      # Spawn a fresh Ruby process that loads the (possibly updated) gem from disk.
+      # The listen socket is inherited via its file descriptor number.
+      def spawn_worker
+        env = {
+          "OCTO_WORKER"      => "1",
+          "OCTO_INHERIT_FD"  => @socket.fileno.to_s,
+          "OCTO_MASTER_PID"  => Process.pid.to_s
+        }
+        # Keep the socket fd open across exec — mark it as non-CLOEXEC.
+        @socket.close_on_exec = false
+
+        # Reconstruct the worker command explicitly.
+        # We cannot rely on ARGV (Thor has already consumed it), so we rebuild
+        # the minimal args: `octo server --host HOST --port PORT [extra_flags]`
+        ruby   = RbConfig.ruby
+        script = File.expand_path($0)
+        worker_argv = ["server", "--host", @host.to_s, "--port", @port.to_s] + @extra_flags
+
+        Octo::Logger.info("[Master PID=#{Process.pid}] spawn: #{ruby} #{script} #{worker_argv.join(' ')}")
+        Octo::Logger.info("[Master PID=#{Process.pid}] env: #{env.inspect}")
+
+        # pgroup: 0 puts worker in its own process group.
+        # This lets Master send TERM/KILL to the entire group (-pid) on shutdown,
+        # ensuring grandchildren (e.g. chrome-devtools-mcp node process) are also
+        # cleaned up even if the worker is force-killed before its shutdown_proc runs.
+        #
+        # NOTE on stdio: we deliberately let the worker inherit Master's fd 0/1/2
+        # so users see startup banner / request logs in their terminal. Protection
+        # against Errno::EPIPE on broken parent stdout is installed inside the
+        # worker itself (see cli.rb worker entry — EPIPESafeIO wrapper).
+        pid = spawn(env, ruby, script, *worker_argv, pgroup: 0)
+        Octo::Logger.info("[Master PID=#{Process.pid}] Spawned worker PID=#{pid} pgroup=#{pid}")
+        pid
+      end
+
+      # Gracefully stop the old worker (so it can persist in-memory sessions),
+      # wait for it to exit, then spawn a new one.
+      def hot_restart
+        old_pid = @worker_pid
+        Octo::Logger.info("[Master] Hot restart: stopping old worker PID=#{old_pid}...")
+
+        # TERM the old worker's process group so grandchildren (node MCP, etc.)
+        # also get a chance to shut down cleanly (triggering interrupt_all_agents).
+        begin
+          Process.kill("TERM", -old_pid)
+          deadline = Time.now + 5
+          loop do
+            pid, = Process.waitpid2(old_pid, Process::WNOHANG)
+            break if pid
+            break if Time.now > deadline
+            sleep 0.1
+          end
+          Process.kill("KILL", -old_pid) rescue nil  # force-kill entire group if still alive
+        rescue Errno::ESRCH
+          # already gone — fine
+        end
+
+        # Old worker is gone; now spawn the replacement.
+        new_pid = spawn_worker
+        @worker_pid = new_pid
+        Octo::Logger.info("[Master] Hot restart complete. New worker PID=#{new_pid}")
+      end
+
+      def shutdown
+        Octo::Logger.info("[Master] Shutting down (worker PID=#{@worker_pid})...")
+        if @worker_pid
+          begin
+            # TERM the entire worker process group so grandchildren (node MCP, etc.)
+            # are also signalled and can clean up before we force-kill.
+            Process.kill("TERM", -@worker_pid)
+            # Wait up to 2s for worker graceful exit, then KILL the whole group
+            deadline = Time.now + 3
+            loop do
+              pid, = Process.waitpid2(@worker_pid, Process::WNOHANG)
+              break if pid
+              if Time.now > deadline
+                Octo::Logger.warn("[Master] Worker did not exit in time, sending KILL...")
+                Process.kill("KILL", -@worker_pid) rescue nil
+                break
+              end
+              sleep 0.1
+            end
+          rescue Errno::ESRCH, Errno::ECHILD
+            # already gone
+          end
+        end
+        @socket.close rescue nil
+        Octo::Logger.info("[Master] Exited.")
+        exit(0)
+      end
+
+      def pid_file_path
+        File.join(Dir.tmpdir, "octo-master-#{@port}.pid")
+      end
+
+      def write_pid_file
+        File.write(pid_file_path, Process.pid.to_s)
+      end
+
+      def remove_pid_file
+        File.delete(pid_file_path) if File.exist?(pid_file_path)
+      end
+
+      def port_free_within?(seconds)
+        deadline = Time.now + seconds
+        loop do
+          begin
+            TCPServer.new(@host, @port).close
+            return true
+          rescue Errno::EADDRINUSE
+            return false if Time.now > deadline
+            sleep 0.1
+          end
+        end
+      end
+
+      # Try to bind to preferred_port, fall back to next ports if occupied.
+      # Returns the bound TCPServer, or nil if all ports in range are occupied.
+      def bind_with_fallback(host, preferred_port, max_port:)
+        (preferred_port..max_port).each do |port|
+          begin
+            server = TCPServer.new(host, port)
+            Octo::Logger.info("[Master] Bound to port #{port}") if port != preferred_port
+            return server
+          rescue Errno::EADDRINUSE
+            next
+          end
+        end
+        nil
+      end
+
+      def print_banner(port_changed: false, original_port: nil)
+        banner = Octo::Banner.new
+        puts ""
+        puts banner.logo
+        puts banner.tagline
+        puts ""
+        
+        if port_changed
+          puts "   [!] Port #{original_port} is in use, using #{@port} instead"
+          puts ""
+        end
+        
+        puts "   Web UI: #{banner.highlight("http://#{@host}:#{@port}")}"
+        puts "   Version: #{Octo::VERSION}"
+        puts "   Press Ctrl-C to stop."
+        puts ""
+      end
+
+      # Scan all fallback port PID files to prevent duplicate masters
+      # when a previous instance bound to a non-default fallback port.
+      def kill_existing_master
+        max_port = (@port == 8888) ? (@port + 5) : @port
+        (@port..max_port).each do |port|
+          kill_master_on_port(port)
+        end
+      end
+
+      private def kill_master_on_port(port)
+        path = File.join(Dir.tmpdir, "octo-master-#{port}.pid")
+        return unless File.exist?(path)
+
+        pid = File.read(path).strip.to_i
+        if pid <= 0
+          File.delete(path) rescue nil
+          return
+        end
+
+        begin
+          Process.kill("TERM", pid)
+          Octo::Logger.info("[Master] Sent TERM to existing master (PID=#{pid}, port=#{port}), waiting...")
+
+          deadline = Time.now + 5
+          until process_dead?(pid) || Time.now > deadline
+            sleep 0.1
+          end
+
+          unless process_dead?(pid)
+            Octo::Logger.warn("[Master] PID=#{pid} still alive after 5s, sending KILL...")
+            Process.kill("KILL", pid) rescue Errno::ESRCH
+          end
+
+          Octo::Logger.info("[Master] Existing master PID=#{pid} (port=#{port}) stopped.")
+        rescue Errno::ESRCH
+          Octo::Logger.info("[Master] Existing master PID=#{pid} already gone.")
+        rescue Errno::EPERM
+          Octo::Logger.warn("[Master] Could not stop existing master (PID=#{pid}) — permission denied.")
+        ensure
+          File.delete(path) if File.exist?(path)
+        end
+      end
+
+      private def process_dead?(pid)
+        Process.kill(0, pid)
+        false
+      rescue Errno::ESRCH
+        true
+      rescue Errno::EPERM
+        false
+      end
+    end
+  end
+end