claude-inbox 0.1.0

data/lib/claude_inbox/paste.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ClaudeInbox
+  # Splits bracketed pastes (what the terminal sends once App turns on
+  # \e[?2004h) out of the raw keypress stream. Pure: no terminal, no IO.
+  #
+  # A paste can straddle several non-blocking reads, so this keeps the open
+  # one between calls and only hands it over once its closing bracket has
+  # arrived. Everything outside the brackets comes back as keys to handle
+  # as before.
+  #
+  #   p = Paste.new
+  #   p.feed("j\e[200~hel")     # => [[:key, "j"]]
+  #   p.feed("lo\e[201~k")      # => [[:paste, "hello"], [:key, "k"]]
+  class Paste
+    OPEN = "\e[200~"
+    CLOSE = "\e[201~"
+
+    def initialize
+      @open = nil
+    end
+
+    def feed(raw)
+      out = []
+      rest = raw.to_s
+      until rest.empty?
+        if @open
+          body, close, rest = rest.partition(CLOSE)
+          @open << body
+          break if close.empty?
+          out << [:paste, @open]
+          @open = nil
+        else
+          keys, open, rest = rest.partition(OPEN)
+          out << [:key, keys] unless keys.empty?
+          @open = +"" unless open.empty?
+        end
+      end
+      out
+    end
+  end
+end

data/lib/claude_inbox/peek.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module ClaudeInbox
+  # The peek pane: whether it is open, which row it is on, how far back it
+  # is scrolled, and what to paint for that. The lines themselves come from
+  # Logs, which it asks on every selection change so that opening the pane
+  # lands on a warm cache. Main-thread state only.
+  class Peek
+    TERMINAL_NOTE = "This is a claude you opened in a terminal yourself. The daemon can't attach to it, read its output, or stop it from outside. Switch to that window."
+    REMOTE_NOTE = "This is a Remote Control session driven from claude.ai/code. The daemon can't attach to it or read its output from here. Open it in the web or mobile app instead."
+
+    # What Renderer paints: the body lines, the title bar, the dim line under it.
+    View = Struct.new(:lines, :title, :subtitle)
+
+    def initialize(logs)
+      @logs = logs
+      @open = false
+      @offset = 0
+      @selected = nil
+      @session = nil
+    end
+
+    def open? = @open
+
+    def toggle
+      @open = !@open
+      @logs.want(@session.id) if @open && @session&.actionable?
+    end
+
+    def close = @open = false
+
+    # Called on every selection change; a fold has no session.
+    def select(selection, session)
+      @selected = selection
+      @session = session
+      @offset = 0
+      @logs.want(session.id) if session&.actionable?
+    end
+
+    # Positive scrolls back into history, negative towards the tail.
+    def scroll(delta)
+      @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.
+    def view(row, height)
+      return nil unless @open && @selected&.row?
+      View.new(scrolled(body(row), height - 2), row&.label || @selected.key, 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
+
+    def interactive_note(s)
+      [s.remote? ? REMOTE_NOTE : TERMINAL_NOTE, "", "pid #{s.pid} · #{s.cwd}", "session #{s.session_id}"]
+    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 || "?"}" }
+      parts.join(" · ")
+    end
+
+    # Lines are shown tail-first; the offset scrolls back into history and is
+    # clamped to however much history there is.
+    def scrolled(lines, view_h)
+      return lines if @offset.zero?
+      max_off = [lines.size - view_h, 0].max
+      @offset = [@offset, max_off].min
+      lines[0, lines.size - @offset]
+    end
+  end
+end

data/lib/claude_inbox/poller.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require_relative "reaper"
+require_relative "sessions"
+require_relative "store"
+
+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.
+  class Poller
+    INTERVAL = 4
+
+    def initialize(client:, store:, pull_requests:, jobs_dir:, reaper:, queue:, interval: INTERVAL)
+      @client = client
+      @store = store
+      @pull_requests = pull_requests
+      @jobs_dir = jobs_dir
+      @reaper = reaper
+      @queue = queue
+      @interval = interval
+      @wake = Queue.new
+      @paused = false
+      @lock = Mutex.new
+    end
+
+    def start
+      return if @thread&.alive?
+      soon
+      @thread = Thread.new { worker }
+    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
+    end
+
+    def soon = @wake << true
+
+    # The rows go up as soon as `claude agents` answers, and the slow calls
+    # (`claude rm`, a dozen serial `gh pr view`s) follow: that is the
+    # difference between the inbox appearing at once and five seconds later.
+    # Every hand-over is the whole list; the store hides the rows the reaper
+    # is about to take, so a list missing a key can only mean the daemon
+    # dropped it. The gh refresh comes last and publishes again only if a PR
+    # state moved.
+    def once
+      now = Time.now
+      sessions = Sessions.load(client: @client, jobs_dir: @jobs_dir, pull_requests: @pull_requests, overrides: @store.pr_overrides)
+      doomed = @reaper.due(sessions, now)
+      @store.hide(doomed)
+      @queue << [:sessions, 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
+      notice_reaped(reaped) if reaped.any?
+      fresh, moved = @pull_requests.refresh(sessions)
+      @queue << [:sessions, fresh] if moved
+    rescue => e
+      @queue << [:error, e.message]
+    end
+
+    private
+
+    # 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?
+      rescue SystemStackError, ScriptError, SecurityError => e
+        @queue << [:error, e.message]
+      end
+    end
+
+    def paused? = @lock.synchronize { @paused }
+
+    def notice_reaped(keys)
+      word = (keys.size == 1) ? "session" : "sessions"
+      @queue << [:notice, "reaped #{keys.size} #{word} idle over #{Store::REAP_AFTER / 86_400}d — see #{@reaper.log_path}"]
+    end
+  end
+end

data/lib/claude_inbox/pull_requests.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "records"
+require_relative "subprocess"
+
+module ClaudeInbox
+  # A pull request tied to a session. `state` uses GitHub's vocabulary plus
+  # DRAFT, the same as Claude Code's own cache: OPEN, DRAFT, MERGED, CLOSED,
+  # or nil when nothing has told us yet.
+  PullRequest = Struct.new(:number, :url, :state, :title) do
+    def short = number ? "##{number}" : url.to_s.sub(%r{\Ahttps?://(www\.)?}, "")
+
+    def merged? = state == "MERGED"
+
+    def closed? = state == "CLOSED"
+
+    # Merged or closed: nothing more will happen to it.
+    def resolved? = merged? || closed?
+
+    def known? = !state.nil?
+  end
+
+  # Finds the PRs a session is tied to and keeps their state fresh.
+  #
+  # Claude Code already does the hard part: the daemon scans each background
+  # session's transcript for links and writes them to the session's job state
+  # file, which JobState reads onto `job_state`; `claude agents --json` does
+  # not expose them.
+  # It is a link scan, so a session that merely mentions a PR gets it too.
+  # Interactive sessions have no job file; for those the store's `pr` override
+  # is the only source.
+  #
+  # State comes first from our own record of resolved PRs, then from
+  # ~/.claude/gh-pr-status-cache.json (whatever Claude Code last saw), then
+  # from `gh pr view` for PRs that are still open, at most once per
+  # REFRESH_AFTER. A merged or closed PR never changes again, so it is never
+  # asked about twice — and once gh has said so, it is written to
+  # RESOLVED_PATH so the next launch does not ask either. Claude Code's cache
+  # only covers PRs its own sessions opened, and a link scan picks up plenty
+  # of others.
+  #
+  # `enrich` never touches gh; it is what stands between `claude agents` and
+  # the first frame. `refresh` is the slow half, one network round trip per
+  # open PR, and the poller calls it after the list has already gone up.
+  class PullRequests
+    REFRESH_AFTER = 60
+
+    CLAUDE_DIR = File.join(Dir.home, ".claude")
+    RESOLVED_PATH = File.join(Dir.home, ".config", "claude-inbox", "prs.json")
+
+    def initialize(cache_path: File.join(CLAUDE_DIR, "gh-pr-status-cache.json"), resolved_path: RESOLVED_PATH,
+      gh: "gh", clock: -> { Time.now })
+      @cache_path = cache_path
+      @resolved_path = resolved_path
+      @gh = gh
+      @clock = clock
+      @known = {}      # url => PullRequest
+      @checked_at = {} # url => epoch seconds of the last gh call
+      @mutex = Mutex.new
+    end
+
+    # Each session with its `prs` set from what is already known, asking
+    # nobody. The scanned links come off `job_state`, so a session without
+    # 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 = {})
+      sessions.map do |s|
+        urls = overrides[s.key] ? [overrides[s.key]] : (s.job_state&.pr_urls || [])
+        s.with(prs: urls.map { |u| known(u) })
+      end
+    end
+
+    # Asks gh about every PR on these sessions that is due. Returns the
+    # sessions with the answers on their `prs` and whether any state changed,
+    # so the caller knows whether the list is worth publishing again.
+    def refresh(sessions)
+      changed = false
+      fresh = sessions.map do |s|
+        s.with(prs: s.prs.map { |pr|
+          status(pr.url).tap { |now| changed = true if now.state != pr.state }
+        })
+      end
+      [fresh, changed]
+    end
+
+    # Best known state for a url without asking gh.
+    def known(url)
+      @mutex.synchronize { @known[url] ||= seed(url) }
+    end
+
+    # Best known state for a url, refreshed through gh when due.
+    def status(url)
+      @mutex.synchronize do
+        pr = @known[url] ||= seed(url)
+        return pr if pr.resolved? || !due?(url)
+        @checked_at[url] = @clock.call.to_i
+        fresh = fetch(url)
+        return pr unless fresh
+        remember(fresh) if fresh.resolved?
+        @known[url] = fresh
+      end
+    end
+
+    # Parse `gh pr view --json` output. Pure so it can be tested.
+    def self.parse(url, json)
+      h = JSON.parse(json)
+      state = (h["state"] == "OPEN" && h["isDraft"]) ? "DRAFT" : h["state"]
+      PullRequest.new(number: h["number"], url: h["url"] || url, state: state, title: h["title"])
+    rescue JSON::ParserError
+      nil
+    end
+
+    # Only an https://github.com/<owner>/<repo>/pull/<n> link makes sense here.
+    def self.valid_url?(url)
+      url.to_s.match?(%r{\Ahttps://github\.com/[^/\s]+/[^/\s]+/pull/\d+/?\z})
+    end
+
+    private
+
+    def due?(url)
+      @gh && @clock.call.to_i - @checked_at.fetch(url, 0) >= REFRESH_AFTER
+    end
+
+    def seed(url)
+      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"))
+    end
+
+    # Same shape as Claude Code's cache, so `seed` reads both alike.
+    def resolved
+      @resolved ||= Records.read(@resolved_path)
+    end
+
+    def claude_cache
+      @claude_cache ||= Records.read(@cache_path)
+    end
+
+    # Under @mutex.
+    def remember(pr)
+      resolved[pr.url] = {"number" => pr.number, "state" => pr.state, "title" => pr.title}
+      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")
+      r.success? ? self.class.parse(url, r.out) : nil
+    rescue SystemCallError
+      nil
+    end
+  end
+end

data/lib/claude_inbox/rate_limits.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "json"
+
+module ClaudeInbox
+  # The subscription's 5-hour and 7-day usage, read from
+  # ~/.claude/rate_limits.json. Nothing writes that file but the user's own
+  # status line script (README, "Usage"): `claude agents --json` says nothing
+  # about limits and there is no CLI command for them, but every session hands
+  # its status line a `rate_limits` object on each turn, so a one-line tee
+  # there is the only source that costs no API calls. No file, or a file
+  # nobody has touched in STALE_AFTER, reads as nothing to show.
+  class RateLimits
+    DEFAULT_PATH = File.join(Dir.home, ".claude", "rate_limits.json")
+    STALE_AFTER = 15 * 60
+
+    def initialize(path: DEFAULT_PATH)
+      @path = path
+      @mtime = nil
+      @data = nil
+    end
+
+    # "usage 5h 23% · 7d 41%", or nil. Parses only when the file has changed,
+    # since render asks several times a second.
+    def label(now = Time.now)
+      mtime = File.mtime(@path)
+      return nil if now - mtime > STALE_AFTER
+      @data = parse if mtime != @mtime
+      @mtime = mtime
+      @data
+    rescue SystemCallError
+      @mtime = @data = nil
+    end
+
+    private
+
+    def parse
+      hash = JSON.parse(File.read(@path))
+      parts = {"five_hour" => "5h", "seven_day" => "7d"}.filter_map do |key, word|
+        pct = hash.dig(key, "used_percentage")
+        "#{word} #{pct.round}%" if pct.is_a?(Numeric)
+      end
+      "usage " + parts.join(" · ") unless parts.empty?
+    rescue JSON::ParserError, TypeError
+      nil
+    end
+  end
+end

data/lib/claude_inbox/reaper.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "store"
+require_relative "agents_client"
+
+module ClaudeInbox
+  # Reaps sessions that have sat idle past Store::REAP_AFTER.
+  #
+  # The one thing in the inbox that destroys anything without being asked
+  # first, so the whole of it lives here rather than spread through the poll
+  # loop: one public method, and one append-only log that is the last record
+  # a session ever existed once `claude rm` has taken its transcript.
+  #
+  # Unpushed work is safe by construction. `claude rm` refuses a worktree
+  # holding commits that aren't pushed and reports a --discard-unpushed token
+  # to override it; nothing here ever passes that token, so a refusal is the
+  # end of it. Refusals are logged and retried at most daily.
+  class Reaper
+    RETRY_AFTER = 24 * 3600
+    DEFAULT_LOG = File.join(Dir.home, ".config", "claude-inbox", "reaped.log")
+
+    attr_reader :log_path
+
+    def initialize(client, store, log_path: DEFAULT_LOG, enabled: self.class.enabled?)
+      @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)
+
+    # Reaps everything due, returning the keys it actually deleted so the
+    # caller can drop those rows before they reach the store. Refusals come
+    # back as survivors rather than exceptions: one worktree with unpushed
+    # commits must not stop the rest of the sweep.
+    #
+    # Raises if the log cannot be opened, before anything is deleted. No
+    # audit trail, no reaping.
+    def sweep(sessions, now)
+      return [] unless @enabled
+      now_i = now.to_i
+      due = sessions.filter_map { |s| row_if_due(s, now_i) }
+      return [] if due.empty?
+      with_log { |log| due.filter_map { |row| reap(row, log, now_i) } }
+    end
+
+    # Keys `sweep` would go after right now, without touching any of them,
+    # so the poller can hand the list over minus these before `claude rm`.
+    def due(sessions, now)
+      return [] unless @enabled
+      now_i = now.to_i
+      sessions.filter_map { |s| row_if_due(s, now_i)&.key }
+    end
+
+    private
+
+    def row_if_due(session, now_i)
+      row = @store.row(session)
+      return nil unless row.reapable?(now_i)
+      backing_off?(row, now_i) ? nil : row
+    end
+
+    def backing_off?(row, now_i)
+      at = row.reap_failed_at
+      !at.nil? && now_i - at.to_i < RETRY_AFTER
+    end
+
+    def reap(row, log, now_i)
+      @client.rm(row.session.id)
+      write(log, row, now_i, "reaped")
+      @store.forget(row.key)
+      row.key
+    rescue AgentsClient::Error => e
+      reason = e.message.lines.first.to_s.strip
+      @store.mark_reap_failed(row.key, reason)
+      write(log, row, now_i, "kept — #{reason}")
+      nil
+    end
+
+    def write(log, row, now_i, outcome)
+      idle_days = (now_i - row.state_since.to_i) / 86_400
+      log.puts([
+        Time.at(now_i).utc.strftime("%FT%TZ"),
+        row.session.id,
+        "idle #{idle_days}d",
+        row.session.display_name.inspect,
+        row.session.cwd,
+        outcome
+      ].join("  "))
+    end
+
+    def with_log
+      FileUtils.mkdir_p(File.dirname(@log_path))
+      File.open(@log_path, "a") { |f| yield f }
+    end
+  end
+end

data/lib/claude_inbox/records.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module ClaudeInbox
+  # The inbox's own records — the snooze table, the resolved PRs — kept
+  # under ~/.config/claude-inbox between launches. Saved atomically (a temp
+  # file beside the target, renamed over it) so a poll mid-write never
+  # reads half a record. Reading a missing or unparsable record yields {}
+  # so callers start from empty instead of failing.
+  module Records
+    module_function
+
+    def read(path)
+      (path && File.exist?(path)) ? JSON.parse(File.read(path)) : {}
+    rescue JSON::ParserError
+      {}
+    end
+
+    def save(path, data)
+      FileUtils.mkdir_p(File.dirname(path))
+      tmp = File.join(File.dirname(path), ".#{File.basename(path)}.#{Process.pid}.tmp")
+      File.write(tmp, JSON.pretty_generate(data))
+      File.rename(tmp, path)
+    end
+  end
+end