claude-inbox 0.3.0 → 0.5.0

data/lib/claude_inbox/app.rb

@@ -11,7 +11,7 @@ require_relative "terminal"
 require_relative "logs"
 require_relative "peek"
 require_relative "keymap"
-require_relative "remote"
+require_relative "remote/listener"
 require_relative "mouse"
 require_relative "new_session_form"
 require_relative "paste"
@@ -20,6 +20,10 @@ require_relative "reaper"
 require_relative "poller"
 require_relative "rate_limits"
 require_relative "session_request"
+require_relative "actions"
+require_relative "snapshot"
+require_relative "switch"
+require_relative "trust"
 
 module ClaudeInbox
   # Owns the terminal and the key loop. The only class allowed to spawn a
@@ -28,19 +32,24 @@ module ClaudeInbox
     # 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,
-      rate_limits: RateLimits.new, reaper: Reaper.disabled, listen: nil, out: $stdout, input: $stdin, color: true,
+      rate_limits: RateLimits.new, reaper: Reaper.disabled, snapshot: Snapshot.disabled, switch: Switch.disabled,
+      actions: Actions.disabled, listen: nil, out: $stdout, input: $stdin, color: true, trust: Trust.method(:projects),
       terminal: Terminal.new(out, input), queue: Queue.new)
       @client = client
       @store = store
+      @snapshot = snapshot
+      @switch = switch
       @rate_limits = rate_limits
       @terminal = terminal
       @color = color
+      @trust = trust
       @renderer = Renderer.new(color: color)
+      @input = input
       @reader = TTY::Reader.new(input: input, output: out, interrupt: :noop)
       @queue = queue
       @poller = Poller.new(client: client, store: store, pull_requests: pull_requests,
-        reaper: reaper, queue: @queue)
-      @listener = listen ? Remote::Listener.new(client: client, store: store, queue: @queue, jobs_dir: client.jobs_dir, **listen) : Remote::Listener.disabled
+        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
@@ -80,8 +89,10 @@ module ClaudeInbox
         @resize = false
         @terminal.resized
       end
-      render
       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?
     end
 
     private
@@ -109,7 +120,6 @@ module ClaudeInbox
         kind, *rest = @queue.pop(true)
         case kind
         when :sessions
-          @store.update(rest[0])
           @last_poll = Time.now
           @error = nil
         when :error then @error = rest[0]
@@ -128,7 +138,19 @@ module ClaudeInbox
     # ----- main loop --------------------------------------------------------
 
     def main_loop
-      step(@reader.read_keypress(echo: false, raw: false, nonblock: true)) until @quit
+      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
     end
 
     def handle_input(raw)
@@ -153,7 +175,9 @@ module ClaudeInbox
     def render
       t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       now = Time.now
-      sections = filtered(@store.sections(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)
@@ -229,6 +253,13 @@ module ClaudeInbox
       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
@@ -276,7 +307,7 @@ module ClaudeInbox
       return if @list_width && col > @list_width
       item = row_item_at(row)
       return unless item
-      select(item.selection)
+      select(item)
       activate
     end
 
@@ -284,7 +315,7 @@ module ClaudeInbox
     # 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]&.kind == :row)
+      @row_items[idx] || (@row_items[idx - 1] if idx > 0 && @row_items[idx - 1]&.row?)
     end
 
     def perform(action)
@@ -389,12 +420,20 @@ module ClaudeInbox
       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)
-      @store.acknowledge(id)
-      @poller.pause
-      @terminal.release { @client.attach(id) }
-    ensure
-      @poller.resume
+      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 -----------------------------------------------------------
@@ -410,13 +449,13 @@ module ClaudeInbox
     end
 
     def open_alias_editor
-      return unless require_storable
+      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
+      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
@@ -441,7 +480,8 @@ module ClaudeInbox
 
     def open_new_session
       cwd = selected_session&.cwd || Dir.pwd
-      @modal = NewSessionForm.new(cwd: SessionRequest.strip_worktree(cwd), pastel: Pastel.new(enabled: @color))
+      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

data/lib/claude_inbox/headless.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "actions"
+require_relative "poller"
+require_relative "pull_requests"
+require_relative "reaper"
+require_relative "snapshot"
+require_relative "writer_lock"
+
+module ClaudeInbox
+  # The poller with no terminal, for a front end that only reads the
+  # snapshot: it polls, writes the file and applies the requests. It never
+  # reaps, since deleting sessions stays with the inbox you can see, and it
+  # exits at once while an inbox holds the writer lock.
+  class Headless
+    def initialize(client:, store:, lock: WriterLock.new)
+      @lock = lock
+      @queue = Queue.new
+      @poller = Poller.new(client: client, store: store, pull_requests: PullRequests.new, reaper: Reaper.disabled,
+        queue: @queue, snapshot: Snapshot.new, actions: Actions.new)
+    end
+
+    # False when the lock is held, by an inbox or another headless process.
+    def run
+      return false unless @lock.take(role: "headless")
+      @poller.start
+      loop { @queue.pop }
+    end
+  end
+end

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, :pr_urls, :color, :intent, :bridge_id
+    attr_reader :pr_urls, :color, :intent, :bridge_id
 
     def initialize(hash)
       @detail = hash["detail"]
@@ -96,7 +96,7 @@ module ClaudeInbox
 
     private
 
-    attr_reader :tempo, :kinds, :tasks, :flags
+    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

data/lib/claude_inbox/keymap.rb

@@ -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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pastel"
 require_relative "agents_client"
 require_relative "images"
 require_relative "session_request"
@@ -18,6 +19,12 @@ module ClaudeInbox
     # string on :choice ones — `kind` says which.
     Field = Struct.new(:key, :label, :kind, :value, :choices)
 
+    # A directory the Directory field offers, shown by its shortest
+    # distinct label as the phone's form shows it.
+    Place = Struct.new(:path, :label, :description) do
+      def to_s = label
+    end
+
     # The screen shows what "default" resolves to; `values` makes it nil.
     DEFAULT = "default"
 
@@ -27,11 +34,13 @@ module ClaudeInbox
     # 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.new(enabled: pastel.enabled)
+    def initialize(cwd:, color:, dirs: [], home: Dir.home, clipboard: Images.method(:from_clipboard))
+      @p = Pastel.new(enabled: color)
+      @theme = Theme.new(enabled: color)
       @home = home
       @clipboard = clipboard
+      @places = dirs.map { |path| Place.new(path, SessionRequest.label(path, dirs), path.sub(/\A#{Regexp.escape(home)}(?=\/|\z)/, "~")) }
+      @dir_settled = cwd.to_s
       @fields = [
         Field.new(:prompt, "Prompt", :multiline, TextBuffer.new),
         Field.new(:name, "Name", :text, TextBuffer.new),
@@ -66,7 +75,7 @@ module ClaudeInbox
       @error = nil
       @candidates = nil
       return :changed if menu && menu_press(name)
-      before = command_query
+      before = menu_query
       case name
       when :escape then return escape_pressed
       when :ctrl_s then return submit(attach: false)
@@ -80,7 +89,7 @@ module ClaudeInbox
       else
         editable? ? focused.value.press(name, raw) : choose(name, raw)
       end
-      edited = before && command_query && command_query != before
+      edited = before && menu_query && menu_query != before
       @pick = 0 if edited
       @dismissed = nil if edited
       :changed
@@ -103,15 +112,12 @@ module ClaudeInbox
       :changed
     end
 
-    def command_query
-      return nil unless focused.key == :prompt
-      focused.value.head[/(?:\A|\s)\/(\S*)\z/, 1]
-    end
-
+    # Slash commands while one is being typed in the prompt; the recent and
+    # trusted directories once the Directory field is edited.
     def menu
-      q = command_query
+      q = menu_query
       return nil if q.nil? || @dismissed == q
-      found = SlashCommands.match(commands, q)
+      found = (focused.key == :cwd) ? places(q) : SlashCommands.match(commands, q)
       found.empty? ? nil : found
     end
 
@@ -124,26 +130,18 @@ module ClaudeInbox
       v[:name] = nil if v[:name].strip.empty?
       v[:cwd] = directory
       v[:remote] = SessionRequest::FLAGS[v[:remote]]
-      SessionRequest.resolve(v, defaults(v[:cwd]))
+      SessionRequest.resolve(v, defaults)
     end
 
     # Settings resolve against the directory the session will run in, so
     # they follow the Directory field.
-    def defaults(cwd = directory)
+    def defaults
+      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 = directory
-      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)
@@ -157,9 +155,12 @@ module ClaudeInbox
       out << ""
       out << "  " + field_label(field(:prompt)) + @p.dim("  ⏎ newline")
       out += prompt_box(field(:prompt), inner_w, prompt_h)
-      out += menu_rows
+      out += menu_rows if focused.key == :prompt
       out << ""
-      @fields[1..].each { |f| out << "  " + field_label(f) + field_value(f, inner_w - 16) }
+      @fields[1..].each do |f|
+        out << "  " + field_label(f) + field_value(f, inner_w - 16)
+        out += menu_rows if f.key == :cwd && focused.key == :cwd
+      end
       out.first(height) + [""] * [height - out.size, 0].max
     end
 
@@ -175,6 +176,7 @@ module ClaudeInbox
         when :choice then [["← → h l", "change"], ["⏎", "next"]]
         else [["⏎", "next"]]
         end
+      keys.unshift(["^U", "recent"]) if focused.key == :cwd && @places.any?
       keys += [["^S", "start"], ["^O", "start & open"],
         ["⇥", (focused.key == :cwd) ? "complete / next" : "next"], ["esc", "cancel"]]
       hints(keys)
@@ -192,6 +194,36 @@ module ClaudeInbox
 
     private
 
+    def menu_query
+      case focused.key
+      when :prompt then focused.value.head[/(?:\A|\s)\/(\S*)\z/, 1]
+      when :cwd then focused.value.to_s unless focused.value.to_s == @dir_settled
+      end
+    end
+
+    def places(query)
+      q = query.downcase
+      found = @places.select { |d| d.path.downcase.include?(q) || d.description.downcase.include?(q) }
+      starts, rest = found.partition { |d| d.label.downcase.start_with?(q) }
+      starts + rest
+    end
+
+    # A path put in the field by a pick or a completion rather than typed,
+    # so the menu stays shut until the next edit.
+    def settle_dir(path)
+      field(:cwd).value.replace(path)
+      @dir_settled = path
+    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?
@@ -219,7 +251,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)
@@ -227,14 +259,18 @@ module ClaudeInbox
       when :up, :ctrl_p then @pick = (@pick - 1) % menu.size
       when :down, :ctrl_n then @pick = (@pick + 1) % menu.size
       when :tab, :return, :enter then accept(picked)
-      when :escape then @dismissed = command_query
+      when :escape then @dismissed = menu_query
       else return false
       end
       true
     end
 
-    def accept(cmd)
-      focused.value.replace_before(command_query.grapheme_clusters.size + 1, "#{cmd} ")
+    def accept(item)
+      if focused.key == :cwd
+        settle_dir(item.path)
+      else
+        focused.value.replace_before(menu_query.grapheme_clusters.size + 1, "#{item} ")
+      end
       @pick = 0
     end
 
@@ -326,10 +362,10 @@ module ClaudeInbox
       matches = Dir.glob(listing ? "#{base}/*" : "#{base}*").select { |d| File.directory?(d) }.sort
       return nil if matches.empty?
       if matches.size == 1
-        focused.value.replace("#{matches.first}/")
+        settle_dir("#{matches.first}/")
       else
         @candidates = matches.map { |d| File.basename(d) }
-        focused.value.replace(common_prefix(matches))
+        settle_dir(common_prefix(matches))
       end
       :changed
     end

data/lib/claude_inbox/painter.rb

@@ -7,9 +7,8 @@ module ClaudeInbox
   # 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, cursor: TTY::Cursor)
+    def initialize(out)
       @out = out
-      @cursor = cursor
       @prev = []
     end
 
@@ -17,11 +16,9 @@ module ClaudeInbox
       buf = +""
       lines.each_with_index do |line, i|
         next if @prev[i] == line
-        buf << @cursor.move_to(0, i) << line
-      end
-      if @prev.size > lines.size
-        (lines.size...@prev.size).each { |i| buf << @cursor.move_to(0, i) << @cursor.clear_line }
+        buf << TTY::Cursor.move_to(0, i) << line
       end
+      (lines.size...@prev.size).each { |i| buf << TTY::Cursor.move_to(0, i) << TTY::Cursor.clear_line }
       @out.print buf unless buf.empty?
       @out.flush
       @prev = lines

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