claude-inbox 0.4.0 → 0.6.0

data/lib/claude_inbox/job_state.rb

@@ -4,7 +4,8 @@ require "json"
 
 module ClaudeInbox
   # What the daemon writes about a background session in
-  # ~/.claude/jobs/<id>/state.json. The only reader of that file.
+  # ~/.claude/jobs/<id>/state.json. The only reader of that file, and the
+  # only writer: a new session's color.
   #
   # `claude agents --json` reports one word, `state`, and "working" covers two
   # different situations: the agent is thinking, or the agent is idle and
@@ -50,6 +51,19 @@ module ClaudeInbox
       nil
     end
 
+    # The job file is there by the time `claude --bg` returns, and the daemon
+    # updates it read-modify-write, so the color stays through work, stop and
+    # respawn (checked on 2.1.296). A color is cosmetic: failing to write one
+    # must not report a started session as failed.
+    # ponytail: a daemon write racing this one can drop the color; re-apply on poll if that shows up.
+    def self.write_color(id, color, jobs_dir:)
+      path = File.join(jobs_dir, id, "state.json")
+      File.write("#{path}.tmp", JSON.generate(JSON.parse(File.read(path)).merge("color" => color)))
+      File.rename("#{path}.tmp", path)
+    rescue JSON::ParserError, SystemCallError
+      nil
+    end
+
     attr_reader :pr_urls, :color, :intent, :bridge_id
 
     def initialize(hash)
@@ -59,7 +73,7 @@ module ClaudeInbox
       @tempo = hash["tempo"]
       @kinds = (hash["fan"] || []).filter_map { |f| f["kind"] }
       @tasks = (hash["inFlight"] || {})["tasks"].to_i
-      @pr_urls = (hash["children"] || []).select { |c| c["kind"] == "pr" && c["href"] }.map { |c| c["href"] }
+      @pr_urls = (hash["children"] || []).filter_map { |c| c["href"] if c["kind"] == "pr" }
       @color = hash["color"]
       @intent = hash["intent"]
       @bridge_id = hash["bridgeSessionId"]

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, "N" => :remote_pairing,
+      "R" => :refresh, "U" => :update, "p" => :toggle_peek, "n" => :new_session, "N" => :remote_pairing,
       :tab => :next_section, :back_tab => :prev_section,
       "/" => :filter, :escape => :escape,
       "q" => :quit, :ctrl_c => :quit

data/lib/claude_inbox/logs.rb

@@ -30,7 +30,6 @@ module ClaudeInbox
     end
 
     def want(id)
-      return if id.nil?
       @pending = id
       @pending_at = @clock.call
     end

data/lib/claude_inbox/mod.rb

@@ -11,6 +11,7 @@ module ClaudeInbox
     DIR = File.expand_path("../../mod", __dir__)
     LINK = File.join(Dir.home, ".config", "claude-inbox", "mod")
     NAME = "inbox-pane"
+    SETTINGS = File.join(Dir.home, ".claude", "settings.json")
     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
@@ -38,7 +39,7 @@ module ClaudeInbox
     # 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)
+    def self.install(settings: SETTINGS, 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"] ||= {}
@@ -61,6 +62,40 @@ module ClaudeInbox
       installed
     end
 
+    # Whether any folder in CLAUDE_CODE_PLUGIN_DIRS holds the pane, a
+    # worktree's included. A settings file it cannot read counts as yes, since
+    # install would refuse to touch it.
+    def self.installed?(settings: SETTINGS)
+      json = File.exist?(settings) ? JSON.parse(File.read(settings)) : {}
+      json.dig("env", "CLAUDE_CODE_PLUGIN_DIRS").to_s.split(File::PATH_SEPARATOR).any? { |d| plugin?(d.strip) }
+    rescue JSON::ParserError, Errno::EACCES
+      true
+    end
+
+    # Asks once, on the first launch that finds the pane missing, whether to
+    # add it. Whatever the answer, a marker file keeps it from asking again.
+    class Offer
+      MARKER = File.join(Dir.home, ".config", "claude-inbox", "pane-offered")
+
+      def self.disabled = new(marker: nil)
+
+      def initialize(marker: MARKER, settings: SETTINGS, link: LINK)
+        @marker = marker
+        @settings = settings
+        @link = link
+      end
+
+      # True once: the first time it is asked while the pane is missing.
+      def take
+        return false if @marker.nil? || File.exist?(@marker) || Mod.installed?(settings: @settings)
+        FileUtils.mkdir_p(File.dirname(@marker))
+        FileUtils.touch(@marker)
+        true
+      end
+
+      def install = Mod.install(settings: @settings, link: @link)
+    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

data/lib/claude_inbox/mouse.rb

@@ -14,7 +14,7 @@ module ClaudeInbox
     # "esc gg" glues onto one read (see App#split_keys), so this scans
     # rather than matching once.
     def self.events(raw)
-      raw.to_s.scan(SEQUENCE).filter_map do |cb, col, row, type|
+      raw.scan(SEQUENCE).filter_map do |cb, col, row, type|
         kind = kind_for(cb.to_i, type)
         Event.new(kind, row.to_i, col.to_i) if kind
       end

data/lib/claude_inbox/new_session_form.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
+require "pastel"
 require_relative "agents_client"
 require_relative "images"
+require_relative "palette"
 require_relative "session_request"
 require_relative "settings"
 require_relative "slash_commands"
@@ -18,6 +20,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,20 +35,24 @@ 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)
+      @palette = Palette.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
       @fields = [
         Field.new(:prompt, "Prompt", :multiline, TextBuffer.new),
         Field.new(:name, "Name", :text, TextBuffer.new),
-        Field.new(:cwd, "Directory", :text, TextBuffer.new(cwd.to_s)),
+        Field.new(:cwd, "Directory", :text, TextBuffer.new(cwd)),
         Field.new(:model, "Model", :choice, DEFAULT, AgentsClient::MODELS),
         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, DEFAULT, [DEFAULT, "no", "yes"])
+        Field.new(:remote, "Remote Control", :choice, DEFAULT, [DEFAULT, "no", "yes"]),
+        Field.new(:color, "Color", :choice, DEFAULT, AgentsClient::COLORS)
       ]
       @focus = 0
       @error = nil
@@ -66,7 +78,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 +92,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,10 +115,12 @@ module ClaudeInbox
       :changed
     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
 
@@ -144,9 +158,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
 
@@ -162,6 +179,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)
@@ -179,9 +197,25 @@ module ClaudeInbox
 
     private
 
-    def command_query
-      return nil unless focused.key == :prompt
-      focused.value.head[/(?:\A|\s)\/(\S*)\z/, 1]
+    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
@@ -228,14 +262,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
 
@@ -285,6 +323,7 @@ module ClaudeInbox
         f.choices.map { |c|
           text = (c == DEFAULT) ? default_text(f) : c
           if c == f.value then (on ? @theme.pill(" #{text} ", :cyan) : @theme.cyan_bold(" #{text} "))
+          elsif f.key == :color then @palette.paint(" #{text} ", c)
           else @p.dim(" #{text} ")
           end
         }.join(" ")
@@ -292,6 +331,7 @@ module ClaudeInbox
     end
 
     def default_text(f)
+      return "none" if f.key == :color
       resolved = defaults[f.key]
       resolved ? "#{resolved} (settings)" : "auto (cli default)"
     end
@@ -327,10 +367,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

@@ -18,9 +18,7 @@ module ClaudeInbox
         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
+      (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/palette.rb

@@ -22,7 +22,7 @@ module ClaudeInbox
 
     RESET = "\e[39m"
 
-    def initialize(enabled: true)
+    def initialize(enabled:)
       @enabled = enabled
     end
 

data/lib/claude_inbox/paste.rb

@@ -24,7 +24,7 @@ module ClaudeInbox
 
     def feed(raw)
       out = []
-      rest = raw.to_s
+      rest = raw
       until rest.empty?
         if @open
           body, close, rest = rest.partition(CLOSE)

data/lib/claude_inbox/peek.rb

@@ -16,7 +16,6 @@ module ClaudeInbox
       @logs = logs
       @open = false
       @offset = 0
-      @selected = nil
       @session = nil
     end
 
@@ -30,8 +29,7 @@ module ClaudeInbox
     def close = @open = false
 
     # Called on every selection change; a fold has no session.
-    def select(selection, session)
-      @selected = selection
+    def select(session)
       @session = session
       @offset = 0
       @logs.want(session.id) if session&.actionable?
@@ -42,17 +40,16 @@ module ClaudeInbox
       @offset = [@offset + delta, 0].max
     end
 
-    # `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.
+    # `row` is the selected row as the frame shows it, or nil on a fold or
+    # with nothing selected. Answers nil when there is no pane to paint.
     def view(row, body_h)
-      return nil unless @open && @selected&.row?
-      View.new(scrolled(body(row), body_h), row&.label || @selected.key, subtitle(row))
+      return nil unless @open && row
+      View.new(scrolled(body(row), body_h), row.label, subtitle(row))
     end
 
     private
 
     def body(row)
-      return ["(nothing selected)"] unless row
       return interactive_note(row.session) if row.session.interactive?
       @logs.cached(row.session.id) || ["(loading…)"]
     end
@@ -62,7 +59,6 @@ module ClaudeInbox
     end
 
     def subtitle(row)
-      return nil unless row
       s = row.session
       parts = [s.effective_state, s.status, s.waiting_for, s.id, s.started_at&.strftime("started %b %-d %H:%M")].compact
       parts += s.prs.map { |pr| "#{pr.short} #{pr.state&.downcase || "?"}" }

data/lib/claude_inbox/poller.rb

@@ -1,13 +1,11 @@
 # frozen_string_literal: true
 
-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, puts what it finds in the store and the snapshot,
-  # and tells App over the shared queue: [:sessions, list] for each
+  # and tells App over the shared queue: [:sessions] after 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
@@ -17,7 +15,7 @@ module ClaudeInbox
     INTERVAL = 4
     ACTIONS_INTERVAL = 0.5
 
-    def initialize(client:, store:, pull_requests:, reaper:, queue:, snapshot: Snapshot.disabled, actions: Actions.disabled,
+    def initialize(client:, store:, pull_requests:, reaper:, queue:, snapshot:, actions:,
       interval: INTERVAL, clock: -> { Time.now })
       @client = client
       @clock = clock
@@ -72,11 +70,9 @@ module ClaudeInbox
       @queue << [:error, e.message]
     end
 
-    # Applies the requests another front end left, and says whether any landed.
+    # Applies the requests another front end left.
     def apply
-      return false unless @actions.drain(@store) > 0
-      write_snapshot
-      true
+      write_snapshot if @actions.drain(@store) > 0
     end
 
     private
@@ -84,7 +80,7 @@ module ClaudeInbox
     def publish(sessions)
       @store.update(sessions)
       write_snapshot
-      @queue << [:sessions, sessions]
+      @queue << [:sessions]
     end
 
     def write_snapshot

data/lib/claude_inbox/pull_requests.rb

@@ -10,7 +10,7 @@ module ClaudeInbox
   # DRAFT, the same as Claude Code's own cache: OPEN, DRAFT, MERGED, CLOSED,
   # or nil when nothing has told us yet. `resolved_at` is when it was merged
   # or closed, in epoch seconds, once gh has said.
-  PullRequest = Struct.new(:number, :url, :state, :title, :resolved_at) do
+  PullRequest = Struct.new(:number, :url, :state, :resolved_at) do
     def short = number ? "##{number}" : url.to_s.sub(%r{\Ahttps?://(www\.)?}, "")
 
     def merged? = state == "MERGED"
@@ -76,7 +76,7 @@ module ClaudeInbox
     # one (interactive, or forgotten) has none; Sessions.load sees to the
     # order. `overrides` maps session key => url for links set by hand; an
     # override replaces the scanned list.
-    def enrich(sessions, overrides = {})
+    def enrich(sessions, overrides)
       sessions.map do |s|
         urls = overrides[s.key] ? [overrides[s.key]] : (s.job_state&.pr_urls || [])
         s.with(prs: urls.map { |u| known(u) })
@@ -115,7 +115,7 @@ module ClaudeInbox
       h = JSON.parse(json)
       state = (h["state"] == "OPEN" && h["isDraft"]) ? "DRAFT" : h["state"]
       resolved_at = h["closedAt"] && Time.iso8601(h["closedAt"]).to_i
-      PullRequest.new(number: h["number"], url: h["url"] || url, state: state, title: h["title"], resolved_at: resolved_at)
+      PullRequest.new(number: h["number"], url: h["url"] || url, state: state, resolved_at: resolved_at)
     rescue JSON::ParserError, ArgumentError
       nil
     end
@@ -140,7 +140,7 @@ module ClaudeInbox
       number = url[%r{/pull/(\d+)}, 1]&.to_i
       cached = resolved[url] || claude_cache[url]
       PullRequest.new(number: cached&.dig("number") || number, url: url, state: cached&.dig("state"),
-        title: cached&.dig("title"), resolved_at: cached&.dig("resolved_at"))
+        resolved_at: cached&.dig("resolved_at"))
     end
 
     # Same shape as Claude Code's cache, so `seed` reads both alike.
@@ -154,13 +154,13 @@ module ClaudeInbox
 
     # Under @mutex.
     def remember(pr)
-      resolved[pr.url] = {"number" => pr.number, "state" => pr.state, "title" => pr.title, "resolved_at" => pr.resolved_at}
+      resolved[pr.url] = {"number" => pr.number, "state" => pr.state, "resolved_at" => pr.resolved_at}
       return unless @resolved_path
       Records.save(@resolved_path, resolved)
     end
 
     def fetch(url)
-      r = Subprocess.capture(@gh, "pr", "view", url, "--json", "number,state,isDraft,title,url,closedAt")
+      r = Subprocess.capture(@gh, "pr", "view", url, "--json", "number,state,isDraft,url,closedAt")
       r.success? ? self.class.parse(url, r.out) : nil
     rescue SystemCallError
       nil

data/lib/claude_inbox/rate_limits.rb

@@ -30,7 +30,7 @@ module ClaudeInbox
     # time, or nil.
     # Parses only when the file has changed, since render asks several times
     # a second.
-    def windows(now = Time.now)
+    def windows(now)
       mtime = File.mtime(@path)
       return nil if now - mtime > STALE_AFTER
       @data = parse if mtime != @mtime

data/lib/claude_inbox/reaper.rb

@@ -20,15 +20,13 @@ module ClaudeInbox
     RETRY_AFTER = 24 * 3600
     DEFAULT_LOG = File.join(Dir.home, ".config", "claude-inbox", "reaped.log")
 
-    def initialize(client, store, log_path: DEFAULT_LOG, enabled: self.class.enabled?)
+    def initialize(client, store, log_path: DEFAULT_LOG, enabled: true)
       @client = client
       @store = store
       @log_path = log_path
       @enabled = enabled
     end
 
-    def self.enabled? = ENV["CLAUDE_INBOX_NO_REAP"].to_s.empty?
-
     # For --fixture runs and tests: selects nothing, deletes nothing, and
     # needs neither a client nor a store to do it.
     def self.disabled = new(nil, nil, enabled: false)
@@ -75,7 +73,7 @@ module ClaudeInbox
       row.key
     rescue AgentsClient::Error => e
       reason = e.message.lines.first.to_s.strip
-      @store.mark_reap_failed(row.key, reason)
+      @store.mark_reap_failed(row.key)
       write(log, row, now_i, "kept — #{reason}")
       nil
     end

data/lib/claude_inbox/remote/http.rb

@@ -12,7 +12,7 @@ module ClaudeInbox
       TOKEN = /\A[!#$%&'*+\-.^_`|~0-9A-Za-z]+\z/
 
       REASONS = {
-        100 => "Continue", 200 => "OK", 201 => "Created", 400 => "Bad Request", 401 => "Unauthorized",
+        200 => "OK", 201 => "Created", 400 => "Bad Request", 401 => "Unauthorized",
         403 => "Forbidden", 404 => "Not Found", 405 => "Method Not Allowed", 409 => "Conflict",
         411 => "Length Required", 413 => "Content Too Large", 415 => "Unsupported Media Type",
         421 => "Misdirected Request", 422 => "Unprocessable Content", 500 => "Internal Server Error",
@@ -107,7 +107,7 @@ module ClaudeInbox
         end
       end
 
-      def self.write(io, status, headers = {}, body = "")
+      def self.write(io, status, headers, body)
         body = body.b
         head = ["HTTP/1.1 #{status} #{REASONS.fetch(status)}"]
         HEADERS.merge(headers, "Content-Length" => body.bytesize.to_s).each { |name, value| head << "#{name}: #{value}" }

data/lib/claude_inbox/remote/listener.rb

@@ -17,7 +17,7 @@ module ClaudeInbox
     # connection limits, the static files and the Pairing token, in front of
     # Start. Like the Poller it reaches App only through the queue, and it
     # never writes to the terminal: every failure becomes a response or a
-    # notice.
+    # notice. It is App's only way into Remote.
     class Listener
       DEFAULT_PORT = 7433
       DEFAULT_MODES = %w[default auto plan].freeze
@@ -58,17 +58,13 @@ module ClaudeInbox
       # lock, as `held_by`) or :failed (for good, as `error` says). `urls` and
       # `firewall` are nil until `refresh`.
       Snapshot = Data.define(:state, :port, :lan, :urls, :firewall, :allowed_modes, :recent, :held_by, :fixture, :error) do
-        def initialize(error: nil, **) = super
-
         # Over a VPN only an address reaches the Mac: multicast DNS, which
         # the .local name needs, stays on the LAN.
         def pairing_url = (lan && urls&.[](1)) || urls&.first
       end
 
       # `count` is how many times `via` got `result`, the last at `at`.
-      Outcome = Data.define(:at, :via, :result, :count) do
-        def initialize(at:, via:, result:, count: 1) = super
-      end
+      Outcome = Data.define(:at, :via, :result, :count)
 
       # App's `listen:` from the flags, else the environment; nil when neither
       # asks for it. --listen-lan wins over --listen, whichever came last.

data/lib/claude_inbox/remote/page.html

@@ -124,6 +124,9 @@ code { font: 15px ui-monospace, SFMono-Regular, Menlo, monospace; }
   <label for="permission_mode">Permissions</label>
   <select id="permission_mode"></select>
   <p class="error" id="error-permission_mode"></p>
+  <label for="color">Color</label>
+  <select id="color"></select>
+  <p class="error" id="error-color"></p>
 
   <div class="toggles">
     <label class="toggle">Worktree <input type="checkbox" id="worktree" switch></label>
@@ -152,7 +155,7 @@ code { font: 15px ui-monospace, SFMono-Regular, Menlo, monospace; }
 const MAX_IMAGES = 8;
 const MAX_BODY = 16777216;
 const LONG_EDGE = 2000;
-const FIELDS = ["prompt", "name", "cwd", "model", "effort", "permission_mode", "images"];
+const FIELDS = ["prompt", "name", "cwd", "model", "effort", "permission_mode", "color", "images"];
 const NO_ANSWER = "no answer from the inbox. Is it open with --listen-lan, and is the Mac awake?";
 const REJECTED = "token rejected: press N in the inbox and pair again";
 const TOKEN = /^[A-Za-z0-9_-]{32,}$/;
@@ -223,9 +226,9 @@ function fill() {
   $("cwd").replaceChildren(...dirs.map((d) => new Option(d.label, d.path)), new Option("another directory…", ""));
   $("cwd").value = typed || !dirs.length ? "" : last || dirs[0].path;
   if (typed) $("cwd-other").value = last;
-  for (const [id, list] of [["model", options.models], ["effort", options.efforts], ["permission_mode", options.permission_modes]]) {
+  for (const [id, list] of [["model", options.models], ["effort", options.efforts], ["permission_mode", options.permission_modes], ["color", options.colors]]) {
     const picked = $(id).value;
-    $(id).replaceChildren(...(list || []).map((v) => new Option(v, v)));
+    $(id).replaceChildren(...(list || []).map((v) => new Option(id === "color" && v === "default" ? "none" : v, v)));
     if ((list || []).includes(picked)) $(id).value = picked;
   }
   relabel();
@@ -380,7 +383,7 @@ async function start() {
     const fields = {
       prompt: $("prompt").value, name: $("name").value, cwd: cwd(),
       model: $("model").value, effort: $("effort").value, permission_mode: $("permission_mode").value,
-      worktree: $("worktree").checked, remote: remote
+      color: $("color").value, worktree: $("worktree").checked, remote: remote
     };
     const body = JSON.stringify({...fields, images: images.map((image) => ({data: image.url.slice(image.url.indexOf(",") + 1)}))});
     const size = new Blob([body]).size;

data/lib/claude_inbox/remote/pairing.rb

@@ -28,7 +28,8 @@ module ClaudeInbox
       # Ethernet and Wi-Fi (en*) first: the first private address is the one
       # `c` copies, and a VM's bridge is no use to a phone.
       def self.addresses(interfaces = Socket.getifaddrs)
-        interfaces.select { |i| i.addr&.ip? }.sort_by.with_index { |i, n| [i.name.start_with?("en") ? 0 : 1, n] }.map(&:addr)
+        en, rest = interfaces.select { |i| i.addr&.ip? }.partition { |i| i.name.start_with?("en") }
+        (en + rest).map(&:addr)
       end
 
       # :off, :on or :block_all; nil without macOS's application firewall.

data/lib/claude_inbox/remote/start.rb

@@ -26,7 +26,7 @@ module ClaudeInbox
       BODY_TIMEOUT = 120
       KEYS_KEPT = 16
 
-      def initialize(client:, store:, queue:, allowed_modes:, fixture: false, images_dir: Images::DEFAULT_DIR,
+      def initialize(client:, store:, queue:, allowed_modes:, fixture:, images_dir: Images::DEFAULT_DIR,
         trust: Trust.method(:projects), settings: Settings.method(:defaults), bridge_wait: 3)
         @client = client
         @store = store
@@ -58,17 +58,12 @@ module ClaudeInbox
           models: AgentsClient::MODELS,
           efforts: AgentsClient::EFFORTS,
           permission_modes: AgentsClient::PERMISSION_MODES & @allowed_modes,
+          colors: AgentsClient::COLORS,
           dirs: paths.map { |path| {path: path, label: SessionRequest.label(path, paths), defaults: @settings.call(path).to_h} }
         }
       end
 
-      # Where sessions ran lately, newest first, then every directory whose
-      # trust dialog was accepted: the likely choices first. Only an order;
-      # the CLI still decides where a session may start.
-      def dir_paths
-        recent = @store.sessions.sort_by { |s| -s.started_at.to_i }.filter_map { |s| s.cwd && SessionRequest.strip_worktree(s.cwd) }
-        (recent + @trust.call).uniq.select { |dir| File.directory?(dir) }
-      end
+      def dir_paths = SessionRequest.directories(@store.sessions, @trust.call)
 
       # Checked cheapest first, and nothing is written to disk until every
       # check has passed. A retry with the same Idempotency-Key gets the