claude-inbox 0.6.1 → 0.7.0

data/lib/claude_inbox/app.rb

@@ -1,20 +1,16 @@
 # frozen_string_literal: true
 
-require "tty-reader"
 require_relative "agents_client"
 require_relative "debug"
 require_relative "dialog"
+require_relative "input"
 require_relative "text_buffer"
 require_relative "store"
 require_relative "renderer"
 require_relative "terminal"
-require_relative "logs"
-require_relative "peek"
 require_relative "keymap"
 require_relative "remote/listener"
-require_relative "mouse"
 require_relative "new_session_form"
-require_relative "paste"
 require_relative "pull_requests"
 require_relative "reaper"
 require_relative "poller"
@@ -26,11 +22,26 @@ require_relative "switch"
 require_relative "trust"
 require_relative "mod"
 require_relative "updater"
+require_relative "app/updating"
+require_relative "app/filtering"
+require_relative "app/triaging"
+require_relative "app/navigating"
+require_relative "app/attaching"
+require_relative "app/spawning"
+require_relative "app/browsing"
 
 module ClaudeInbox
   # Owns the terminal and the key loop. The only class allowed to spawn a
   # child process that takes over the terminal.
   class App
+    include Updating
+    include Filtering
+    include Triaging
+    include Navigating
+    include Attaching
+    include Spawning
+    include Browsing
+
     # The reaper deletes sessions and the listener lets other machines in,
     # so both are off unless `bin/claude-inbox` switches them on.
     def initialize(client: AgentsClient.new, store: Store.new, pull_requests: PullRequests.new,
@@ -49,24 +60,20 @@ module ClaudeInbox
       @color = color
       @trust = trust
       @renderer = Renderer.new(color: color)
-      @input = input
-      @reader = TTY::Reader.new(input: input, output: out, interrupt: :noop)
+      @input = Input.new(input, out)
       @queue = queue
       @poller = Poller.new(client: client, store: store, pull_requests: pull_requests,
         reaper: reaper, queue: @queue, snapshot: snapshot, actions: actions)
       @listener = listen ? Remote::Listener.new(client: client, store: store, queue: @queue, **listen) : Remote::Listener.disabled
-      @logs = Logs.new(client)
-      @peek = Peek.new(@logs)
       @selected = nil
       @row_items = []
-      @list_width = nil
       @top = 0
       @expanded = Hash.new(false)
       @keymap = Keymap.new
-      @paste = Paste.new
       @tick = 0
       @modal = nil
       @filter = nil
+      @filter_editing = false
       @last_poll = nil
       @quit = false
       @resize = false
@@ -80,19 +87,16 @@ module ClaudeInbox
       @terminal.enter
       @poller.start
       @listener.start
-      @logs.start
       main_loop
     ensure
       @poller.stop
-      @logs.stop
       @terminal.restore
       @listener.stop
     end
 
     def step(input = nil)
-      check_for_update unless @update_status
+      ensure_update_checked
       drain_queue
-      @logs.tick
       if @resize
         @resize = false
         @terminal.resized
@@ -100,7 +104,7 @@ module ClaudeInbox
       handle_input(input) if input
       # A paste arrives a character per read and shows nothing until it
       # closes, so a frame per character would only stall a long one.
-      render unless @paste.pasting?
+      render unless @input.pasting?
     end
 
     private
@@ -111,8 +115,6 @@ module ClaudeInbox
       trap("WINCH") { @resize = true } if Signal.list.key?("WINCH")
     end
 
-    # ----- threads ----------------------------------------------------------
-
     # Runs a block off the main thread; a failure lands in the status line
     # rather than killing the thread silently.
     def in_background
@@ -133,39 +135,26 @@ module ClaudeInbox
         when :error then @error = rest[0]
         when :notice then notice(rest[0])
         when :update then update_checked(*rest)
-        when :select then @pending_select = rest[0]
+        when :select then select_later(rest[0])
         when :attach then attach(rest[0])
-        when :form_started then @modal = nil if @modal.equal?(rest[0])
+        when :form_started then form_started(rest[0])
         when :form_failed then form_failed(*rest)
         when :remote_started then remote_started(*rest)
         end
       end
     end
 
-    # ----- main loop --------------------------------------------------------
-
     def main_loop
-      step(@paste.pasting? ? read_pasted : @reader.read_keypress(echo: false, raw: false, nonblock: true)) until @quit
-    end
-
-    # As much of an open paste as has arrived, read straight off the tty:
-    # the reader switches echo off and back on around every character, and
-    # on a long paste that is most of the wait.
-    def read_pasted
-      return nil unless @input.wait_readable(0.1)
-      out = +""
-      while out.size < 65_536 && @input.wait_readable(0) && (c = @input.getc)
-        out << c
-      end
-      out
+      step(@input.read) until @quit
     end
 
     def handle_input(raw)
-      @paste.feed(raw).each do |kind, text|
-        next handle_paste(text) if kind == :paste
-        events = Mouse.events(text)
-        next events.each { |e| handle_mouse(e) } if events.any?
-        split_keys(text).each { |k| handle_key(k) }
+      @input.events(raw).each do |kind, *event|
+        case kind
+        when :paste then handle_paste(*event)
+        when :mouse then handle_mouse(*event)
+        when :key then handle_key(*event)
+        end
       end
     end
 
@@ -175,163 +164,13 @@ module ClaudeInbox
     # "y" answers a confirm.
     def handle_paste(text)
       return @modal.paste(text) if @modal.is_a?(NewSessionForm)
-      typing = @modal ? @modal.is_a?(Dialog::Prompt) : @filter_editing
-      text.each_char { |c| handle_key(c) } if typing
-    end
-
-    def render
-      t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      now = Time.now
-      all = @store.sections(now)
-      @snapshot.write(all, now)
-      sections = filtered(all)
-      width, height = @terminal.size
-      body_h = Renderer.body_height(height)
-      ensure_selection(sections)
-      @tick += 1
-      view = Renderer::View.new(
-        width: width, height: height, now: now, selected: @selected&.key, top: @top, expanded: @expanded,
-        peek: @peek.view(sections.row(@selected), body_h), modal: modal_lines(width), screen: screen_lines(width, body_h),
-        status: status_text(now), usage: @rate_limits.windows(now), filter: @filter, filter_editing: @filter_editing,
-        tick: @tick / 2, loading: loading_for, listening: @listener.snapshot
-      )
-      frame = @renderer.frame(sections, view)
-      @row_items = frame.items
-      @list_width = frame.list_width
-      @top = frame.top
-      @terminal.paint(frame.lines)
-      dt = Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0
-      Debug.log("render #{(dt * 1000).round}ms") if dt > 0.05
-    end
-
-    # Seconds spent waiting for the first poll; nil once one has landed, or
-    # failed — a failure has its own line in the header and the empty state
-    # already says how to retry.
-    def loading_for
-      return nil if @last_poll || @error || !@booted_at
-      Process.clock_gettime(Process::CLOCK_MONOTONIC) - @booted_at
-    end
-
-    def status_text(now)
-      return @notice[0] if @notice && now < @notice[1]
-      return "⚠ #{@error}" if @error
-      return "polling…" unless @last_poll
-      "#{@update.notice} · U updates" if @update
-    end
-
-    # ----- updates ----------------------------------------------------------
-
-    # Once, on the first step: a stale cache means a network round trip, so
-    # it runs off the main thread. A laptop that is offline stays quiet
-    # rather than show an error at every launch; U says what went wrong.
-    def check_for_update
-      @update_status = @updater ? "checking for updates…" : "update check is off — claude-inbox update installs the latest"
-      return unless @updater
-      in_background do
-        @queue << [:update, @updater.check]
-      rescue Updater::Error => e
-        @queue << [:update, nil, e.message]
-      end
-    end
-
-    def update_checked(update, failure = nil)
-      @update = update
-      @snapshot.update = update&.notice
-      @update_status = failure ? "couldn't check for updates: #{failure}" : "up to date"
-    end
-
-    # The install prints on the real screen, and the relaunch replaces this
-    # process. A failed install relaunches this version instead, once its
-    # error has been read, rather than leave the shell showing.
-    def update_inbox
-      return notice(@update_status) unless @update
-      @terminal.release do
-        @out.puts @update.installing
-        applied = @updater.apply
-        @out.puts applied.output unless applied.output.empty?
-        @terminal.pause unless applied.success?
-        relaunch
-      end
-    end
-
-    def relaunch
-      @updater.relaunch(@argv)
-    rescue SystemCallError => e
-      @error = "relaunch failed: #{e.message}"
-    end
-
-    def filtered(sections = @store.sections) = sections.matching(@filter&.to_s)
-
-    def ensure_selection(sections)
-      stops = sections.selections(@expanded)
-      pending = @pending_select && Store::Selection.row(@pending_select)
-      if pending && stops.include?(pending)
-        select(pending)
-        @pending_select = nil
-        return
-      end
-      return if stops.include?(@selected)
-      select(stops.first)
-    end
-
-    def select(selection)
-      @selected = selection
-      @peek.select(selected_session)
-    end
-
-    def session_for(key) = @store.sessions.find { |s| s.key == key }
-
-    def selected_session = session_for(@selected&.key)
-
-    # Guard for attach/stop: refuse politely on a terminal or remote row.
-    def require_actionable
-      s = selected_session
-      return true if s&.actionable?
-      if s&.interactive?
-        notice(s.remote? ? "that's a remote session — Enter adopts it, w opens it at claude.ai/code" : "that's your own terminal — switch to that window")
-      end
-      false
+      typing = @modal ? @modal.is_a?(Dialog::Prompt) : filter_editing?
+      @input.typed(text).each { |name, c| handle_key(name, c) } if typing
     end
 
-    # Guard for snooze/wake/alias: anything with a key, since those live in
-    # our own store. A terminal you are sitting in is the one exception.
-    def require_storable
-      s = selected_session
-      return true if @selected&.row? && !s&.terminal?
-      notice("you're in that terminal right now — nothing to snooze") if s&.terminal?
-      false
-    end
-
-    # The edits with no request form, which a second inbox cannot keep.
-    def require_writable(verb)
-      return true if @store.writable?
-      notice("another claude-inbox owns state.json — #{verb} there")
-      false
-    end
-
-    def notice(msg)
-      @notice = [msg, Time.now + 4]
-    end
-
-    # ----- keys -------------------------------------------------------------
-
-    def key_name(key)
-      @reader.console.keys[key] || key
-    end
-
-    # tty-reader glues ESC to whatever arrives within 100ms, so a fast
-    # "esc gg" comes in as one unknown key "\egg". Vim hands make that
-    # constantly. Unknown ESC-prefixed strings become ESC + the rest.
-    def split_keys(key)
-      return [key] if key.size <= 1 || @reader.console.keys.key?(key)
-      return [key] unless key.start_with?("\e")
-      ["\e"] + key[1..].chars
-    end
-
-    def handle_key(key)
-      name = key_name(key)
+    def handle_key(name, key)
       return handle_modal_key(name, key) if @modal
-      return handle_line_key(name, key) if @filter_editing
+      return handle_line_key(name, key) if filter_editing?
 
       action = @keymap.press(name, key)
       perform(action) if action
@@ -341,30 +180,32 @@ module ClaudeInbox
     # the normal action table (see handle_key); mouse input defers to the
     # same rule rather than reaching past whatever has focus.
     def handle_mouse(event)
-      return if @modal || @filter_editing
+      return if @modal || filter_editing?
       case event.kind
-      when :click then click_row(event.row, event.col)
+      when :click then click_row(event.row)
       when :scroll_up then perform(:up)
       when :scroll_down then perform(:down)
       end
     end
 
-    # Clicking a row selects it and attaches, same as landing on it with
-    # j/k and pressing Enter — activate already knows how to expand a fold
-    # or refuse a terminal/remote row, so this doesn't repeat that.
-    def click_row(row, col)
-      return if @list_width && col > @list_width
-      item = row_item_at(row)
-      return unless item
-      select(item)
-      activate
-    end
-
-    # The wrapped detail line under a two-line row ("↳ ~/code/x") carries
-    # no item of its own; a click there resolves to the row above it.
-    def row_item_at(row)
-      idx = row - 1
-      @row_items[idx] || (@row_items[idx - 1] if idx > 0 && @row_items[idx - 1]&.row?)
+    def handle_modal_key(name, key)
+      return handle_form_key(name, key) if @modal.is_a?(NewSessionForm)
+      case @modal.press(name, key)
+      when :cancel then @modal = nil
+      when :snooze then snooze_chosen
+      when :confirm
+        kind, id = @modal.kind, @modal.id
+        @modal = nil
+        case kind
+        when :stop then stop_session(id)
+        when :delete then delete_session(id)
+        when :adopt then adopt_session(id)
+        when :install then install_pane
+        end
+      when :save then save_prompt
+      when :copy then @listener.copy_pairing_url
+      when :rotate then @listener.rotate
+      end
     end
 
     def perform(action)
@@ -380,13 +221,10 @@ module ClaudeInbox
       when :page_up then move(-page)
       when :next_section then jump_section(1)
       when :prev_section then jump_section(-1)
-      when :peek_down then @peek.scroll(-1)
-      when :peek_up then @peek.scroll(1)
       when :activate then activate
-      when :collapse then collapse
       when :fold_open then set_expanded(true)
       when :fold_close then set_expanded(false)
-      when :fold_toggle then set_expanded(!@expanded[current_fold_section])
+      when :fold_toggle then toggle_expanded
       when :snooze then open_snooze_menu
       when :wake then wake_selected
       when :toggle_pin then toggle_pin_selected
@@ -399,7 +237,6 @@ module ClaudeInbox
       when :delete then open_confirm(:delete)
       when :refresh then @poller.soon
       when :update then update_inbox
-      when :toggle_peek then toggle_peek
       when :new_session then open_new_session
       when :remote_pairing then @modal = @listener.pairing_dialog
       when :filter then start_filter
@@ -407,161 +244,34 @@ module ClaudeInbox
       end
     end
 
-    def page = [Renderer.body_height(@terminal.size[1]), 1].max
-
-    def move(delta)
-      stops = filtered.selections(@expanded)
-      return if stops.empty?
-      idx = stops.index(@selected) || 0
-      select(stops[(idx + delta).clamp(0, stops.size - 1)])
-    end
-
-    # Tab / Shift-Tab: first selectable row of the next / previous section.
-    def jump_section(dir)
-      sections = filtered
-      heads = sections.heads(@expanded)
-      return if heads.empty?
-      current = sections.section_of(@selected)
-      idx = heads.index { |name, _| name == current } || -1
-      select(heads[(idx + dir) % heads.size].last)
-    end
-
-    # The foldable section the cursor is currently on or inside, if any.
-    def current_fold_section
-      name = filtered.section_of(@selected)
-      name if Store::FOLDABLE_SECTIONS.include?(name)
-    end
-
-    def set_expanded(value)
-      name = current_fold_section
-      @expanded[name] = value if name
-    end
-
-    # vim-ish "h": close whatever is open, innermost first.
-    def collapse
-      if @peek.open? then @peek.close
-      elsif (name = current_fold_section) && @expanded[name] then @expanded[name] = false
-      end
-      @terminal.invalidate
-    end
-
-    def activate
-      return @expanded[@selected.key] = true if @selected&.fold?
-      return @modal = Dialog::Confirm.new(:adopt, @selected.key) if selected_session&.remote?
-      attach(@selected.key) if require_actionable
-    end
-
-    def toggle_peek
-      @peek.toggle
-      @terminal.invalidate
-    end
-
-    def wake_selected
-      @store.wake(@selected.key) if require_storable
-    end
-
-    def toggle_pin_selected
-      @store.toggle_pin(@selected.key) if require_storable
-    end
-
-    def settle_selected
-      return unless require_storable
-      @store.settle(@selected.key)
-      notice("settled — u brings it back")
-    end
-
-    # The pane in the attached session may ask for a different one: the
-    # attach ends and the next starts without passing through the list. The
-    # poller keeps running meanwhile, so the pane's snapshot stays fresh. A
-    # failed attach leaves its reason on screen until a key is pressed.
-    def attach(id)
-      while id
-        @store.acknowledge(id)
-        @switch.clear
-        from = session_for(id)&.session_id
-        @terminal.release do
-          @terminal.pause unless @client.attach(id) { @switch.requested_for?(from) }
-        end
-        id = @switch.take(@store.sessions.select(&:actionable?).map(&:key))
-      end
-    end
-
-    # ----- modals -----------------------------------------------------------
-
-    def open_snooze_menu
-      return unless require_storable
-      @modal = Dialog::Snooze.new(@selected.key)
-    end
-
-    def open_confirm(kind)
-      return unless require_actionable
-      @modal = Dialog::Confirm.new(kind, @selected.key)
-    end
-
-    def open_alias_editor
-      return unless require_storable && require_writable("rename")
-      current = @store.alias_for(@selected.key) || ""
-      @modal = Dialog::Prompt.new(:alias, @selected.key, current)
-    end
-
-    def open_pr_editor
-      return unless require_storable && require_writable("link a pull request")
-      current = @store.pr_for(@selected.key) || selected_session&.pr&.url || ""
-      @modal = Dialog::Prompt.new(:pr, @selected.key, current)
-    end
-
-    def open_pr
-      pr = selected_session&.pr
-      return notice("no pull request linked — P sets one") unless pr
-      open_in_browser(pr.url, pr.short)
-    end
-
-    def open_remote
-      url = selected_session&.remote_url
-      return notice("no claude.ai/code page for this session") unless url
-      open_in_browser(url, "claude.ai/code")
-    end
-
-    def open_in_browser(url, what)
-      opener = RUBY_PLATFORM.include?("darwin") ? "open" : "xdg-open"
-      notice("opening #{what}")
-      in_background { Subprocess.capture(opener, url) }
-    end
-
-    def open_new_session
-      cwd = selected_session&.cwd || Dir.pwd
-      dirs = SessionRequest.directories(@store.sessions, @trust.call)
-      @modal = NewSessionForm.new(cwd: SessionRequest.strip_worktree(cwd), color: @color, dirs: dirs)
-    end
-
-    # `attach:` hands the terminal over as soon as the session starts. Without
-    # it we stay in the inbox and poll, so the new row shows up right away
-    # rather than at the next tick.
-    def start_session(form, attach:)
-      v = form.values
-      notice("starting session…")
-      in_background do
-        id = @client.spawn(**v)
-        @queue << [:notice, "started #{id}"]
-        @queue << [:form_started, form]
-        @queue << [:select, id]
-        attach ? @queue << [:attach, id] : @poller.soon
-      rescue AgentsClient::Error => e
-        @queue << [:form_failed, form, e.message]
-      end
-    end
-
-    # Someone at the desk may be mid-thought, so a start from another
-    # device never moves the cursor, attaches or closes what is open.
-    def remote_started(id, via)
-      notice("started #{id} from #{via}")
-      @poller.soon
+    def install_pane
+      @pane_offer.install
+      notice("added the pane — new Claude Code sessions load it; /inbox opens it")
+    rescue JSON::ParserError
+      notice("~/.claude/settings.json is not valid JSON, so it was left alone")
     end
 
-    # A spawn failure hands the form back rather than just logging it, so
-    # the composed prompt survives (see NewSessionForm#submission_failed).
-    def form_failed(form, message)
-      @modal.equal?(form) ? form.submission_failed(message) : (@error = message)
+    def render
+      t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      now = Time.now
+      all = @store.sections(now)
+      @snapshot.write(all, now)
+      sections = filtered(all)
+      width, height = @terminal.size
+      body_h = Renderer.body_height(height)
+      ensure_selection(sections)
+      @tick += 1
+      view = Renderer::View.new(
+        width: width, height: height, now: now, selected: @selected&.key, top: @top, expanded: @expanded,
+        modal: modal_lines(width), screen: screen_lines(width, body_h),
+        status: status_text(now), usage: @rate_limits.windows(now), filter: filter, filter_editing: filter_editing?,
+        tick: @tick / 2, loading: loading_for, listening: @listener.snapshot
+      )
+      frame = @renderer.frame(sections, view)
+      placed(frame)
+      @terminal.paint(frame.lines)
+      dt = Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0
+      Debug.log("render #{(dt * 1000).round}ms") if dt > 0.05
     end
 
     # The new-session form takes the whole body; a Dialog is a box over it.
@@ -574,110 +284,23 @@ module ClaudeInbox
       @modal.frame(width, @renderer.caret) if @modal.is_a?(Dialog)
     end
 
-    def handle_modal_key(name, key)
-      return handle_form_key(name, key) if @modal.is_a?(NewSessionForm)
-      case @modal.press(name, key)
-      when :cancel then @modal = nil
-      when :snooze
-        @store.snooze(@modal.id, @modal.choice)
-        @modal = nil
-      when :confirm
-        kind, id = @modal.kind, @modal.id
-        @modal = nil
-        case kind
-        when :stop then stop_session(id)
-        when :delete then delete_session(id)
-        when :adopt then adopt_session(id)
-        when :install then install_pane
-        end
-      when :save then save_prompt
-      when :copy then @listener.copy_pairing_url
-      when :rotate then @listener.rotate
-      end
-    end
-
-    # `:start`/`:start_and_attach` leave the form as `@modal`, now busy: it
-    # closes itself once the spawn is confirmed to have started (`:form_started`)
-    # or reopens with the failure and the prompt intact (`:form_failed`).
-    def handle_form_key(name, key)
-      form = @modal
-      case form.press(name, key)
-      when :cancel then @modal = nil
-      when :start then start_session(form, attach: false)
-      when :start_and_attach then start_session(form, attach: true)
-      end
-    end
-
-    def stop_session(id)
-      in_background do
-        @client.stop(id)
-        @poller.soon
-      end
-    end
-
-    def adopt_session(key)
-      s = session_for(key)
-      return unless s&.remote?
-      notice("adopting #{s.display_name}…")
-      in_background do
-        id = @client.adopt(session_id: s.session_id, cwd: s.cwd, pid: s.pid)
-        @queue << [:notice, "adopted as #{id}"]
-        @queue << [:select, id]
-        @queue << [:attach, id]
-      end
-    end
-
-    def install_pane
-      @pane_offer.install
-      notice("added the pane — new Claude Code sessions load it; /inbox opens it")
-    rescue JSON::ParserError
-      notice("~/.claude/settings.json is not valid JSON, so it was left alone")
-    end
-
-    def delete_session(id)
-      notice("deleting #{id}…")
-      in_background do
-        @client.rm(id)
-        @store.forget(id)
-        @queue << [:notice, "deleted #{id}"]
-        @poller.soon
-      end
-    end
-
-    def save_prompt
-      value = @modal.value.strip
-      if @modal.kind == :alias
-        @store.set_alias(@modal.id, value)
-      elsif value.empty? || PullRequests.valid_url?(value)
-        @store.set_pr(@modal.id, value)
-        @poller.soon
-      else
-        return notice("that's not a github.com pull request url")
-      end
-      @modal = nil
-    end
-
-    # ----- filter line --------------------------------------------------------
-
-    def start_filter
-      @filter ||= TextBuffer.new
-      @filter_editing = true
+    def status_text(now)
+      return @notice[0] if @notice && now < @notice[1]
+      return "⚠ #{@error}" if @error
+      return "polling…" unless @last_poll
+      update_notice
     end
 
-    def clear_filter
-      @filter = nil
-      @filter_editing = false
+    # Seconds spent waiting for the first poll; nil once one has landed, or
+    # failed — a failure has its own line in the header and the empty state
+    # already says how to retry.
+    def loading_for
+      return nil if @last_poll || @error || !@booted_at
+      Process.clock_gettime(Process::CLOCK_MONOTONIC) - @booted_at
     end
 
-    def handle_line_key(name, key)
-      case name
-      when :escape then clear_filter
-      when :return, :enter then @filter_editing = false
-      when :backspace, :ctrl_h
-        @filter.empty? ? clear_filter : @filter.press(name, key)
-      else
-        @filter.press(name, key)
-      end
+    def notice(msg)
+      @notice = [msg, Time.now + 4]
     end
   end
 end