claude-inbox 0.2.0 → 0.4.0

data/lib/claude_inbox/job_state.rb

@@ -38,19 +38,19 @@ module ClaudeInbox
     # Each background session with its job file read onto `job_state`, or nil
     # when there is none: interactive sessions have no job file, and neither
     # does one the daemon has already forgotten. Sessions.load calls this.
-    def self.enrich(sessions, jobs_dir: DEFAULT_DIR)
+    def self.enrich(sessions, jobs_dir:)
       sessions.map { |s| s.background? ? s.with(job_state: read(s.id, jobs_dir: jobs_dir)) : s }
     end
 
     # => JobState, or nil when there is no readable file for this id.
-    def self.read(id, jobs_dir: DEFAULT_DIR)
+    def self.read(id, jobs_dir:)
       return nil unless id
       new(JSON.parse(File.read(File.join(jobs_dir, id, "state.json"))))
     rescue JSON::ParserError, SystemCallError
       nil
     end
 
-    attr_reader :detail, :needs, :result, :tempo, :kinds, :tasks, :pr_urls, :color, :intent, :bridge_id, :flags
+    attr_reader :pr_urls, :color, :intent, :bridge_id
 
     def initialize(hash)
       @detail = hash["detail"]
@@ -70,16 +70,22 @@ module ClaudeInbox
     # a wake, are the only record of Remote Control being on it.
     def remote_control? = flags.include?("--remote-control")
 
-    # The agent itself is not thinking. On its own this means little — a
-    # session whose process died leaves the same reading behind — so it only
-    # says something paired with work still in flight.
-    def agent_idle? = tempo == "idle"
-
-    def in_flight? = tasks.positive?
-
     # True when the agent has stopped and is only waiting on what it started.
     def waiting_on_work? = agent_idle? && in_flight?
 
+    # What the session needs while blocked, what it produced once done,
+    # otherwise its status line; nil before it has said anything.
+    def summary(state)
+      line =
+        case state
+        when "blocked" then needs || detail
+        when "done" then result || detail
+        else detail
+        end
+      line = line.to_s.gsub(/\s+/, " ").strip
+      line.empty? ? nil : line
+    end
+
     # "1 shell", "2 agents · 1 shell". Falls back to a bare count for a state
     # file that counts the open tasks without naming them.
     def in_flight_label
@@ -90,6 +96,15 @@ module ClaudeInbox
 
     private
 
+    attr_reader :detail, :needs, :result, :tempo, :kinds, :tasks, :flags
+
+    # The agent itself is not thinking. On its own this means little — a
+    # session whose process died leaves the same reading behind — so it only
+    # says something paired with work still in flight.
+    def agent_idle? = tempo == "idle"
+
+    def in_flight? = tasks.positive?
+
     def count_label = "#{tasks} #{plural("task", tasks)}"
 
     def plural(word, n) = (n == 1) ? word : "#{word}s"

data/lib/claude_inbox/keymap.rb

@@ -27,7 +27,7 @@ module ClaudeInbox
       "s" => :snooze, "u" => :wake, "a" => :alias, "x" => :settle, "X" => :stop,
       :ctrl_x => :delete,
       "o" => :open_pr, "P" => :link_pr, "t" => :toggle_pin, "w" => :open_remote,
-      "R" => :refresh, "p" => :toggle_peek, "n" => :new_session,
+      "R" => :refresh, "p" => :toggle_peek, "n" => :new_session, "N" => :remote_pairing,
       :tab => :next_section, :back_tab => :prev_section,
       "/" => :filter, :escape => :escape,
       "q" => :quit, :ctrl_c => :quit
@@ -38,8 +38,6 @@ module ClaudeInbox
       "z" => {"o" => :fold_open, "c" => :fold_close, "a" => :fold_toggle}
     }.freeze
 
-    attr_reader :pending
-
     def initialize(clock: -> { Time.now })
       @clock = clock
       @pending = nil

data/lib/claude_inbox/mod.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+
+module ClaudeInbox
+  # Where the Claude Code pane ships, and a path to it that holds still: the
+  # gem's own folder moves with every version, so a link under ~/.config is
+  # what settings.json names, refreshed by the installed gem on every launch.
+  module Mod
+    DIR = File.expand_path("../../mod", __dir__)
+    LINK = File.join(Dir.home, ".config", "claude-inbox", "mod")
+    NAME = "inbox-pane"
+    CHECKOUT = File.exist?(File.expand_path("../../.git", __dir__))
+    # What the pane runs headless: a checkout's own, or the gem's from PATH.
+    COMMAND = CHECKOUT ? File.expand_path("../../bin/claude-inbox", __dir__) : nil
+
+    # Points the link at this gem's mod folder and returns the link. A folder
+    # of that name that is not a link is left alone. From a checkout only a
+    # missing or dangling link is made, unless forced (`--mod-dir` asks for
+    # it), so a worktree's launch never takes the path from the installed gem.
+    def self.link(link: LINK, dir: DIR, force: false, checkout: CHECKOUT)
+      FileUtils.mkdir_p(File.dirname(link))
+      return link if File.exist?(link) && !File.symlink?(link)
+      if File.symlink?(link)
+        return link if File.readlink(link) == dir
+        return link if checkout && !force && File.directory?(File.readlink(link))
+        File.delete(link)
+      end
+      File.symlink(dir, link)
+      link
+    end
+
+    Installed = Data.define(:added, :removed, :command_set)
+
+    # Links the mod and adds the link to CLAUDE_CODE_PLUGIN_DIRS in Claude
+    # Code's user settings, keeping any folders already there; forced, it
+    # drops the other folders holding this plugin, such as a worktree's, and
+    # sets the command the pane runs to this copy's. Raises JSON::ParserError
+    # rather than rewrite a settings file it cannot read.
+    def self.install(settings: File.join(Dir.home, ".claude", "settings.json"), link: LINK, dir: DIR, force: false, command: COMMAND)
+      self.link(link: link, dir: dir, force: true)
+      json = File.exist?(settings) ? JSON.parse(File.read(settings)) : {}
+      env = json["env"] ||= {}
+      dirs = env["CLAUDE_CODE_PLUGIN_DIRS"].to_s.split(File::PATH_SEPARATOR).map(&:strip).reject(&:empty?)
+      kept = dirs.reject { |d| force && d != link && plugin?(d) }
+      wanted = kept.include?(link) ? kept : [*kept, link]
+      options = json.dig("pluginConfigs", NAME, "options") || {}
+      replace = force && options["command"] != command
+      installed = Installed.new(added: !kept.include?(link), removed: dirs - kept, command_set: replace)
+      return installed if wanted == dirs && !replace
+
+      if replace
+        command ? options["command"] = command : options.delete("command")
+        ((json["pluginConfigs"] ||= {})[NAME] ||= {})["options"] = options
+      end
+      env["CLAUDE_CODE_PLUGIN_DIRS"] = wanted.join(File::PATH_SEPARATOR)
+      FileUtils.mkdir_p(File.dirname(settings))
+      File.write("#{settings}.tmp", JSON.pretty_generate(json) + "\n")
+      File.rename("#{settings}.tmp", settings)
+      installed
+    end
+
+    def self.plugin?(folder)
+      JSON.parse(File.read(File.join(folder, ".claude-plugin", "plugin.json")))["name"] == NAME
+    rescue Errno::ENOENT, Errno::ENOTDIR, Errno::EACCES, JSON::ParserError
+      false
+    end
+    private_class_method :plugin?
+  end
+end

data/lib/claude_inbox/new_session_form.rb

@@ -2,6 +2,7 @@
 
 require_relative "agents_client"
 require_relative "images"
+require_relative "session_request"
 require_relative "settings"
 require_relative "slash_commands"
 require_relative "text"
@@ -17,15 +18,18 @@ module ClaudeInbox
     # string on :choice ones — `kind` says which.
     Field = Struct.new(:key, :label, :kind, :value, :choices)
 
-    # "default" stays the internal value so spawn_args leaves the flag off;
-    # the screen shows what that resolves to instead.
+    # The screen shows what "default" resolves to; `values` makes it nil.
     DEFAULT = "default"
 
     MENU_ROWS = 6
 
-    def initialize(cwd:, pastel:, theme: Theme.new(enabled: pastel.enabled), home: Dir.home, clipboard: Images.method(:from_clipboard))
+    # Keys a :choice field answers to, as the step through its choices; an
+    # editable field spends these on its own text instead.
+    CYCLE = {:left => -1, :right => 1, "h" => -1, "l" => 1, " " => 1}.freeze
+
+    def initialize(cwd:, pastel:, home: Dir.home, clipboard: Images.method(:from_clipboard))
       @p = pastel
-      @theme = theme
+      @theme = Theme.new(enabled: pastel.enabled)
       @home = home
       @clipboard = clipboard
       @fields = [
@@ -36,7 +40,7 @@ module ClaudeInbox
         Field.new(:effort, "Effort", :choice, DEFAULT, AgentsClient::EFFORTS),
         Field.new(:permission_mode, "Permissions", :choice, DEFAULT, AgentsClient::PERMISSION_MODES),
         Field.new(:worktree, "Worktree", :choice, "no", %w[no yes]),
-        Field.new(:remote, "Remote Control", :choice, "no", %w[no yes])
+        Field.new(:remote, "Remote Control", :choice, DEFAULT, [DEFAULT, "no", "yes"])
       ]
       @focus = 0
       @error = nil
@@ -99,11 +103,6 @@ module ClaudeInbox
       :changed
     end
 
-    def command_query
-      return nil unless focused.key == :prompt
-      focused.value.head[/(?:\A|\s)\/(\S*)\z/, 1]
-    end
-
     def menu
       q = command_query
       return nil if q.nil? || @dismissed == q
@@ -114,33 +113,24 @@ module ClaudeInbox
     def picked = menu&.fetch(@pick.clamp(0, menu.size - 1))
 
     def values
-      @fields.to_h { |f| [f.key, f.value.to_s] }.tap do |v|
-        v[:prompt] = field(:prompt).value.expand { |chip| AgentsClient.mention(chip.path) }.strip
-        v[:worktree] = v[:worktree] == "yes"
-        v[:remote] = v[:remote] == "yes"
-        v[:name] = nil if v[:name].strip.empty?
-        v[:cwd] = File.expand_path(v[:cwd].strip.empty? ? "." : v[:cwd].strip)
-      end
+      v = @fields.to_h { |f| [f.key, (f.kind == :choice && f.value == DEFAULT) ? nil : f.value.to_s] }
+      v[:prompt] = field(:prompt).value.expand { |chip| AgentsClient.mention(chip.path) }.strip
+      v[:worktree] = v[:worktree] == "yes"
+      v[:name] = nil if v[:name].strip.empty?
+      v[:cwd] = directory
+      v[:remote] = SessionRequest::FLAGS[v[:remote]]
+      SessionRequest.resolve(v, defaults)
     end
 
     # Settings resolve against the directory the session will run in, so
     # they follow the Directory field.
     def defaults
-      cwd = values[:cwd]
+      cwd = directory
       return @defaults if @defaults_for == cwd
       @defaults_for = cwd
       @defaults = Settings.defaults(cwd, home: @home)
     end
 
-    # Project commands live under the Directory field's path, so they
-    # follow it as the defaults do.
-    def commands
-      cwd = values[:cwd]
-      return @commands if @commands_for == cwd
-      @commands_for = cwd
-      @commands = SlashCommands.list(cwd: cwd, home: @home)
-    end
-
     # Full-screen body: a tall prompt editor, then one row per setting with
     # every choice visible. Exactly `height` lines.
     def screen(width, height)
@@ -189,6 +179,20 @@ module ClaudeInbox
 
     private
 
+    def command_query
+      return nil unless focused.key == :prompt
+      focused.value.head[/(?:\A|\s)\/(\S*)\z/, 1]
+    end
+
+    # Project commands live under the Directory field's path, so they
+    # follow it as the defaults do.
+    def commands
+      cwd = directory
+      return @commands if @commands_for == cwd
+      @commands_for = cwd
+      @commands = SlashCommands.list(cwd: cwd, home: @home)
+    end
+
     # Esc with a prompt typed asks first, so a stray keypress can't lose it.
     def escape_pressed
       return :cancel if field(:prompt).value.empty?
@@ -216,7 +220,7 @@ module ClaudeInbox
 
     def insert(text)
       return unless editable?
-      focused.value.insert((focused.kind == :multiline) ? text : text.tr("\n", " "))
+      (focused.kind == :multiline) ? focused.value.paste(text) : focused.value.insert(text.tr("\n", " "))
     end
 
     def menu_press(name)
@@ -344,38 +348,25 @@ module ClaudeInbox
 
     def field(key) = @fields.find { |f| f.key == key }
 
+    def directory
+      path = field(:cwd).value.to_s.strip
+      File.expand_path(path.empty? ? "." : path)
+    end
+
     def focus_on(key) = @focus = @fields.index { |f| f.key == key }
 
-    # Keys a :choice field answers to; an editable field spends these on its
-    # own text instead.
     def choose(name, raw)
-      case name
-      when :left then cycle(-1)
-      when :right then cycle(1)
-      else
-        case raw
-        when "h" then cycle(-1)
-        when "l", " " then cycle(1)
-        end
-      end
-    end
-
-    def cycle(d)
+      d = CYCLE[name] || CYCLE[raw]
+      return unless d
       f = focused
-      return unless f.kind == :choice
       f.value = f.choices[(f.choices.index(f.value) + d) % f.choices.size]
     end
 
     def submit(attach:)
-      v = values
-      if v[:prompt].empty?
-        @error = "a prompt is required"
-        focus_on(:prompt)
-        return :changed
-      end
-      unless File.directory?(v[:cwd])
-        @error = "no such directory: #{v[:cwd]}"
-        focus_on(:cwd)
+      field, message = SessionRequest.problem(values)
+      if field
+        @error = message
+        focus_on(field)
         return :changed
       end
       @busy = true

data/lib/claude_inbox/painter.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "tty-cursor"
+
+module ClaudeInbox
+  # Diffs successive frames and writes only changed rows. No erase-to-end-of-
+  # line after a row: in the terminal's last column the cursor stays put
+  # (pending wrap), so EL would eat the glyph just drawn.
+  class Painter
+    def initialize(out)
+      @out = out
+      @prev = []
+    end
+
+    def paint(lines)
+      buf = +""
+      lines.each_with_index do |line, i|
+        next if @prev[i] == line
+        buf << TTY::Cursor.move_to(0, i) << line
+      end
+      if @prev.size > lines.size
+        (lines.size...@prev.size).each { |i| buf << TTY::Cursor.move_to(0, i) << TTY::Cursor.clear_line }
+      end
+      @out.print buf unless buf.empty?
+      @out.flush
+      @prev = lines
+    end
+
+    def invalidate = @prev = []
+  end
+end

data/lib/claude_inbox/palette.rb

@@ -17,13 +17,10 @@ module ClaudeInbox
 
     INDEXED = {"orange" => 208, "pink" => 205}.freeze
 
-    RESET = "\e[39m"
+    SEQUENCES = ANSI.transform_values { |n| "\e[#{n}m" }
+      .merge(INDEXED.transform_values { |n| "\e[38;5;#{n}m" }).freeze
 
-    def self.sequence(name)
-      return "\e[#{ANSI[name]}m" if ANSI.key?(name)
-      return "\e[38;5;#{INDEXED[name]}m" if INDEXED.key?(name)
-      nil
-    end
+    RESET = "\e[39m"
 
     def initialize(enabled: true)
       @enabled = enabled
@@ -31,7 +28,7 @@ module ClaudeInbox
 
     def paint(text, name)
       return text unless @enabled
-      seq = self.class.sequence(name)
+      seq = SEQUENCES[name]
       seq ? seq + text + RESET : text
     end
   end

data/lib/claude_inbox/paste.rb

@@ -20,6 +20,8 @@ module ClaudeInbox
       @open = nil
     end
 
+    def pasting? = !@open.nil?
+
     def feed(raw)
       out = []
       rest = raw.to_s

data/lib/claude_inbox/peek.rb

@@ -44,9 +44,9 @@ module ClaudeInbox
 
     # `row` is the selected row as the frame shows it, or nil when nothing is
     # selected. Answers nil when there is no pane to paint.
-    def view(row, height)
+    def view(row, body_h)
       return nil unless @open && @selected&.row?
-      View.new(scrolled(body(row), height - 2), row&.label || @selected.key, subtitle(row))
+      View.new(scrolled(body(row), body_h), row&.label || @selected.key, subtitle(row))
     end
 
     private

data/lib/claude_inbox/poller.rb

@@ -1,47 +1,46 @@
 # frozen_string_literal: true
 
-require_relative "reaper"
+require_relative "actions"
 require_relative "sessions"
+require_relative "snapshot"
 
 module ClaudeInbox
   # Asks `claude agents` for the list off the main thread, every INTERVAL
-  # seconds and on demand, and hands what it finds to App over the shared
-  # queue: [:sessions, list] for each hand-over, [:error, msg] when a poll
-  # fails, [:notice, text] when the reaper took something. Nothing here
-  # touches App's state directly; the queue is the whole of the interface.
-  # One worker runs every poll, so two can never overlap and publish the
-  # list out of order.
+  # seconds and on demand, puts what it finds in the store and the snapshot,
+  # and tells App over the shared queue: [:sessions, list] for each
+  # hand-over, [:error, msg] when a poll fails, [:notice, text] when the
+  # reaper took something. Between polls it applies what another front end
+  # asked for. Nothing here touches App's state directly; the queue is the
+  # whole of the interface. One worker runs every poll, so two can never
+  # overlap and publish the list out of order.
   class Poller
     INTERVAL = 4
+    ACTIONS_INTERVAL = 0.5
 
-    def initialize(client:, store:, pull_requests:, reaper:, queue:, interval: INTERVAL, clock: -> { Time.now })
+    def initialize(client:, store:, pull_requests:, reaper:, queue:, snapshot: Snapshot.disabled, actions: Actions.disabled,
+      interval: INTERVAL, clock: -> { Time.now })
       @client = client
       @clock = clock
       @store = store
       @pull_requests = pull_requests
       @reaper = reaper
       @queue = queue
+      @snapshot = snapshot
+      @actions = actions
       @interval = interval
       @wake = Queue.new
-      @paused = false
-      @lock = Mutex.new
     end
 
     def start
       return if @thread&.alive?
       soon
       @thread = Thread.new { worker }
+      @applier = Thread.new { applier }
     end
 
-    def stop = @thread&.kill
-
-    # Skips the poll rather than the timer, so nothing forks `claude` while
-    # another process holds the terminal. A poll already under way finishes.
-    def pause = @lock.synchronize { @paused = true }
-
-    def resume
-      @lock.synchronize { @paused = false }
-      soon
+    def stop
+      @thread&.kill
+      @applier&.kill
     end
 
     def soon = @wake << true
@@ -58,35 +57,60 @@ module ClaudeInbox
       sessions = Sessions.load(client: @client, pull_requests: @pull_requests, overrides: @store.pr_overrides)
       doomed = @reaper.due(sessions, now)
       @store.hide(doomed)
-      @queue << [:sessions, sessions]
+      publish(sessions)
       reaped = []
       begin
         reaped = @reaper.sweep(sessions.select { |s| doomed.include?(s.key) }, now)
       ensure
         @store.release(doomed - reaped)
       end
-      @queue << [:sessions, sessions] if reaped != doomed
+      publish(sessions) if reaped != doomed
       @queue << [:notice, @reaper.report(reaped)] if reaped.any?
       fresh, moved = @pull_requests.refresh(sessions)
-      @queue << [:sessions, fresh] if moved
+      publish(fresh) if moved
     rescue => e
       @queue << [:error, e.message]
     end
 
+    # Applies the requests another front end left, and says whether any landed.
+    def apply
+      return false unless @actions.drain(@store) > 0
+      write_snapshot
+      true
+    end
+
     private
 
+    def publish(sessions)
+      @store.update(sessions)
+      write_snapshot
+      @queue << [:sessions, sessions]
+    end
+
+    def write_snapshot
+      now = @clock.call
+      @snapshot.write(@store.sections(now), now)
+    end
+
     # Past StandardError `once` does not catch, and a dead worker would end
     # polling with nothing on screen to say so.
     def worker
       loop do
         @wake.pop(timeout: @interval)
         @wake.clear
-        once unless paused?
+        once
       rescue SystemStackError, ScriptError, SecurityError => e
         @queue << [:error, e.message]
       end
     end
 
-    def paused? = @lock.synchronize { @paused }
+    def applier
+      loop do
+        sleep ACTIONS_INTERVAL
+        apply
+      rescue => e
+        @queue << [:error, e.message]
+      end
+    end
   end
 end