claude-inbox 0.3.0 → 0.5.0

data/lib/claude_inbox/snapshot.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "records"
+
+module ClaudeInbox
+  # The sections as the screen shows them, written to a file for another
+  # front end to read, so the triage rules run once, here. Rewritten when
+  # the rows change and every HEARTBEAT seconds regardless, so a reader can
+  # tell a quiet inbox from one that has quit.
+  class Snapshot
+    DEFAULT_PATH = File.join(Dir.home, ".config", "claude-inbox", "snapshot.json")
+    HEARTBEAT = 5
+
+    def self.disabled = new(path: nil)
+
+    def initialize(path: DEFAULT_PATH)
+      @path = path
+      @body = nil
+      @written_at = nil
+      @mutex = Mutex.new
+    end
+
+    # Called from the poller's threads and the screen's alike.
+    def write(sections, now)
+      return unless @path
+      body = sections.to_h { |name, rows| [name.to_s, rows.map { |row| row_hash(row) }] }
+      @mutex.synchronize do
+        return if body == @body && now.to_i - @written_at < HEARTBEAT
+        @body = body
+        @written_at = now.to_i
+        Records.save(@path, {"version" => 1, "written_at" => @written_at, "sections" => body})
+      end
+    end
+
+    private
+
+    def row_hash(row)
+      s = row.session
+      pr = s.pr
+      {
+        "id" => row.key, "session" => s.session_id, "label" => row.label, "state" => s.effective_state, "actionable" => s.actionable?,
+        "waiting" => s.waiting_on_work? || nil, "line" => s.summary, "wake_at" => row.wake_at, "remote" => s.remote_url,
+        "pr" => pr && {"short" => pr.short, "state" => pr.state&.downcase, "url" => pr.url}
+      }.compact
+    end
+  end
+end

data/lib/claude_inbox/store/entry.rb

@@ -69,8 +69,6 @@ module ClaudeInbox
       # When `claude rm` last refused this session, so the Reaper backs off.
       def reap_failed_at = @h["reap_failed_at"]
 
-      def reap_error = @h["reap_error"]
-
       def stale?(now) = last_seen && now.to_i - last_seen > PRUNE_AFTER
 
       def observe(session, now)

data/lib/claude_inbox/store/row.rb

@@ -5,8 +5,6 @@ module ClaudeInbox
     # A session paired with its Entry (nil until a poll has recorded one), with
     # the triage rules as its methods; each takes `now`, so a Row is pure.
     Row = Struct.new(:session, :entry) do
-      def id = session.id
-
       def key = session.key
 
       def selectable? = !key.nil?
@@ -66,12 +64,16 @@ module ClaudeInbox
       # Resolved PRs settle a `blocked` row too: asking "anything need
       # changing?" leaves it blocked, and merging answers it. `failed` stays
       # in view even if its PR landed; a PR nobody knows the state of yet
-      # (no gh, offline) is ignored.
+      # (no gh, offline) is ignored. So is one resolved before the session
+      # started: reviewing an old PR, or the CLI resolving a bare PR number
+      # against the wrong repo, would otherwise hide a session waiting on you.
+      # Until gh says when a PR was resolved, it holds the row in view.
       def settled?
         return true if hand_settled?
         return false if UNSETTLEABLE.include?(session.effective_state)
-        known = session.prs.select(&:known?)
-        known.any? && known.all?(&:resolved?)
+        started = session.started_at.to_i
+        ours = session.prs.select(&:known?).reject { |pr| pr.resolved_before?(started) }
+        ours.any? && ours.all? { |pr| pr.resolved_since?(started) }
       end
 
       # Idle time is the only clock, not the Settled section: the PR rule holds

data/lib/claude_inbox/store.rb

@@ -20,6 +20,7 @@ module ClaudeInbox
     # should see it, but after REAP_AFTER of not seeing it, you never will.
     UNREAPABLE = %w[working].freeze
     SECTIONS = %i[pinned needs_you active snoozed settled].freeze
+    NotWritable = Class.new(StandardError)
     # Sections long enough to be worth hiding behind a fold toggle.
     FOLDABLE_SECTIONS = %i[snoozed settled].freeze
 
@@ -56,9 +57,15 @@ module ClaudeInbox
 
     DEFAULT_PATH = File.join(Dir.home, ".config", "claude-inbox", "state.json")
 
-    def initialize(path: DEFAULT_PATH, clock: -> { Time.now })
+    # A store that is not `writable` reads the file but never saves it: the
+    # second inbox open at once, which reads along with the first rather
+    # than overwriting what it and the pane's requests settled, and sends
+    # its own edits to the first through the `relay` as requests.
+    def initialize(path: DEFAULT_PATH, clock: -> { Time.now }, writable: true, relay: nil)
       @path = path
       @clock = clock
+      @writable = writable
+      @relay = relay
       @mutex = Mutex.new
       @sessions = []
       @hidden = Set.new
@@ -74,7 +81,7 @@ module ClaudeInbox
         @hidden &= keys
         @forgotten &= keys
         @sessions = sessions.reject { |s| @hidden.include?(s.key) || @forgotten.include?(s.key) }
-        @entries = self.class.merge_entries(@entries, @sessions, @clock.call)
+        @entries = self.class.merge_entries(@writable ? @entries : load, @sessions, @clock.call)
         save
       end
     end
@@ -85,17 +92,19 @@ module ClaudeInbox
 
     def sessions = @mutex.synchronize { @sessions.dup }
 
-    def snooze(id, choice) = edit(id) { |e| e.snooze(choice, @clock.call) }
+    def writable? = @writable
 
-    def wake(id) = edit(id) { |e| e.wake(@clock.call) }
+    def snooze(id, choice) = edit(id, "snooze", choice: choice.to_s) { |e| e.snooze(choice, @clock.call) }
 
-    def acknowledge(id) = edit(id) { |e| e.acknowledge(@clock.call) }
+    def wake(id) = edit(id, "wake") { |e| e.wake(@clock.call) }
 
-    def settle(id) = edit(id) { |e| e.settle(@clock.call) }
+    def acknowledge(id) = edit(id, "acknowledge") { |e| e.acknowledge(@clock.call) }
+
+    def settle(id) = edit(id, "settle") { |e| e.settle(@clock.call) }
 
     def mark_reap_failed(id, message) = edit(id) { |e| e.mark_reap_failed(@clock.call, message) }
 
-    def toggle_pin(id) = edit(id) { |e| e.toggle_pin(@clock.call) }
+    def toggle_pin(id) = edit(id, "pin") { |e| e.toggle_pin(@clock.call) }
 
     def set_alias(id, name) = edit(id) { |e| e.alias = name }
 
@@ -144,11 +153,17 @@ module ClaudeInbox
 
     private
 
-    def edit(id)
+    # A store that cannot save still makes the change here, for the screen,
+    # and asks the writer for it by `action` through the relay, so the next
+    # poll finds it done rather than undone. An edit with no request form
+    # would only be undone, so it is refused outright.
+    def edit(id, action = nil, **detail)
+      raise NotWritable, "another claude-inbox owns state.json" if !@writable && action.nil?
       @mutex.synchronize do
         yield Entry.new(@entries[id] ||= Entry.blank(@clock.call).to_h)
         save
       end
+      @relay&.request(action, id, **detail) if !@writable && action
     end
 
     def load
@@ -156,7 +171,7 @@ module ClaudeInbox
     end
 
     def save
-      return unless @path
+      return unless @path && @writable
       Records.save(@path, {"version" => 1, "sessions" => @entries})
     end
   end

data/lib/claude_inbox/switch.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "records"
+
+module ClaudeInbox
+  # A request from another front end to attach to a different session: one
+  # file, written by the asker and taken by the inbox attached to the asker's
+  # own session. Only that inbox can act on it, which is why the asker gives
+  # up on a request nobody takes, and why the request names who asked.
+  class Switch
+    DEFAULT_PATH = File.join(Dir.home, ".config", "claude-inbox", "switch.json")
+
+    def self.disabled = new(path: nil)
+
+    def initialize(path: DEFAULT_PATH)
+      @path = path
+    end
+
+    # Whether the session `from` has asked to go elsewhere.
+    def requested_for?(from)
+      return false if from.nil?
+      Records.read(@path)["from"] == from
+    end
+
+    # The requested id if it is one of `attachable`, and the request is gone either way.
+    def take(attachable)
+      id = Records.read(@path)["id"]
+      clear
+      attachable.include?(id) ? id : nil
+    end
+
+    def clear
+      File.delete(@path) if @path
+    rescue Errno::ENOENT
+      nil
+    end
+  end
+end

data/lib/claude_inbox/terminal.rb

@@ -76,6 +76,14 @@ module ClaudeInbox
       enter
     end
 
+    # Inside `release`: keeps what a failed child printed on the screen
+    # until a key is pressed, since `enter` would cover it at once.
+    def pause
+      @out.print "\r\npress any key to return to claude-inbox"
+      @out.flush
+      @input.tty? ? @input.getch : @input.getc
+    end
+
     # [cols, rows]. Cached: querying the terminal can fall back to spawning
     # `tput`, which is far too slow to do on every frame. Refreshed by
     # `resized`, which WINCH and re-entry both call.

data/lib/claude_inbox/text_buffer.rb

@@ -9,20 +9,34 @@ module ClaudeInbox
   #
   # Positions count cells, not bytes or characters. A cell is a grapheme
   # cluster — prompts and session names carry emoji, and character indexes
-  # cut them in half — or a Chip, an attached image that shows as one
-  # `[Image #1]` token and moves and deletes as one unit, the way Claude
-  # Code's own prompt treats a pasted image.
+  # cut them in half — or a chip: an attached Image or a long Pasted text,
+  # each shown as one token (`[Image #1]`, `[Pasted text #1 +40 lines]`)
+  # that moves and deletes as one unit, the way Claude Code's own prompt
+  # treats them.
   #
   #   b = TextBuffer.new("ab")
   #   b.press(:left, "\e[D")
   #   b.press("X", "X")
   #   b.to_s                    # => "aXb"
   class TextBuffer
-    Chip = Struct.new(:n, :path) do
+    Image = Struct.new(:n, :path) do
       def to_s = "[Image ##{n}]"
     end
 
+    Pasted = Struct.new(:n, :text) do
+      def to_s
+        lines = text.count("\n")
+        "[Pasted text ##{n} #{(lines > 0) ? "+#{lines} lines" : "#{text.size} chars"}]"
+      end
+    end
+
+    # Past either, a paste folds into a Pasted chip: laid out in full it
+    # buries the prompt around it, and wrapping it costs every frame.
+    FOLD_CHARS = 800
+    FOLD_LINES = 10
+
     def initialize(text = "")
+      @widths = Hash.new { |h, s| h[s] = Text.width(s) }
       @g = text.grapheme_clusters
       @cursor = @g.size
     end
@@ -31,13 +45,17 @@ module ClaudeInbox
 
     def empty? = @g.empty?
 
-    # Grapheme offset of the cursor. Rendering goes through #row / #view;
-    # this is here for callers that need to reason about position (tests).
-    attr_reader :cursor
-
-    def chips = @g.grep(Chip)
-
-    def expand = @g.map { |c| c.is_a?(Chip) ? yield(c) : c }.join
+    # The text as it will be sent: a Pasted chip unfolds to its text, and
+    # the block says what each Image becomes.
+    def expand
+      @g.map { |c|
+        case c
+        when Image then yield(c)
+        when Pasted then c.text
+        else c
+        end
+      }.join
+    end
 
     # Swaps the whole text out and parks the cursor at the end — what
     # completion wants after it extends a path.
@@ -62,13 +80,13 @@ module ClaudeInbox
       @cursor += g.size
     end
 
-    # Numbered after the chips already in the text, so a second image is
+    # Chips are numbered per kind and never reused, so a second image is
     # `[Image #2]` even after the first was deleted, as Claude Code does.
-    def attach(path)
-      chip = Chip.new(@next_chip = (@next_chip || 0) + 1, path)
-      @g.insert(@cursor, chip)
-      @cursor += 1
-      chip
+    def attach(path) = place(Image.new(@images = (@images || 0) + 1, path))
+
+    def paste(text)
+      return insert(text) if text.size <= FOLD_CHARS && text.count("\n") < FOLD_LINES
+      place(Pasted.new(@pastes = (@pastes || 0) + 1, text))
     end
 
     # Handles one keypress — readline's editing keys, plus printable text —
@@ -98,12 +116,18 @@ module ClaudeInbox
     # gets plain truncated text instead.
     def row(width, cursor: nil)
       return Text.truncate(to_s, width) unless cursor
-      first = 0
-      first += 1 while width_of(@g[first...@cursor]) > width - 1
+      first = @cursor
+      used = 0
+      while first > 0 && used + cell_width(@g[first - 1]) <= width - 1
+        first -= 1
+        used += cell_width(@g[first])
+      end
       cells = []
+      used = 0
       @g[first..].each do |c|
-        break if width_of(cells) + width_of([c]) > width
+        break if used + cell_width(c) > width
         cells << c
+        used += cell_width(c)
       end
       paint(cells, @cursor - first, cursor)
     end
@@ -129,12 +153,14 @@ module ClaudeInbox
 
     private
 
-    def width_of(cells) = cells.sum { |c| Text.width(c.to_s) }
+    def width_of(cells) = cells.sum { |c| cell_width(c) }
+
+    def cell_width(cell) = @widths[cell.to_s]
 
     def paint(cells, offset, cursor, chip = nil)
       out = cells.each_with_index.map do |c, i|
         s = c.to_s
-        s = chip.call(s) if chip && c.is_a?(Chip)
+        s = chip.call(s) if chip && !c.is_a?(String)
         (i == offset) ? cursor.call(s) : s
       end
       out << cursor.call(" ") if offset && offset >= cells.size
@@ -160,29 +186,48 @@ module ClaudeInbox
 
     # Text.wrap on cells, keeping the trailing spaces the cursor may sit on:
     # a chip is one cell however wide its label, so the wrap has to measure
-    # cells rather than a joined string.
+    # cells rather than a joined string. Widths are kept running rather than
+    # re-measured per word: this runs every frame, over the whole prompt.
     def segments(cells, width)
-      return [cells] if width_of(cells) <= width
-      words = cells.slice_when { |c, _| c == " " }.to_a
       lines = []
       line = []
-      words.each do |word|
-        if !line.empty? && width_of(line) + width_of(word.reverse.drop_while { |c| c == " " }) > width
+      used = 0
+      cells.slice_when { |c, _| c == " " }.each do |word|
+        word_w = width_of(word)
+        bare_w = (word.last == " ") ? word_w - 1 : word_w
+        if !line.empty? && used + bare_w > width
           lines << line
           line = []
+          used = 0
         end
-        while width_of(word) > width
-          cut = word.size - 1
-          cut -= 1 while cut > 0 && width_of(word[0...cut]) > width
-          lines << word[0...cut]
-          word = word[cut..]
+        at = 0
+        while word_w > width
+          cut, cut_w = fit(word, at, width)
+          lines << word[at...at + cut]
+          at += cut
+          word_w -= cut_w
         end
-        line += word
+        line.concat(word[at..])
+        used += word_w
       end
       lines << line unless line.empty?
       lines
     end
 
+    # How many cells of `word` from `at` fit in `width`, and their width.
+    # Always at least one, so a glyph wider than the box still moves on.
+    def fit(word, at, width)
+      count = 0
+      used = 0
+      (at...word.size).each do |i|
+        w = cell_width(word[i])
+        break if count > 0 && used + w > width
+        count += 1
+        used += w
+      end
+      [count, used]
+    end
+
     # The newline itself belongs to the line it ends, so a cursor sitting on
     # it lands past the end of that line rather than at the start of the next.
     def logical_lines
@@ -200,6 +245,12 @@ module ClaudeInbox
 
     def cursor_row(rows) = rows.rindex { |_, start| start <= @cursor } || 0
 
+    def place(chip)
+      @g.insert(@cursor, chip)
+      @cursor += 1
+      chip
+    end
+
     def delete(at, length)
       return if at < 0 || length <= 0
       @g.slice!(at, length)

data/lib/claude_inbox/writer_lock.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module ClaudeInbox
+  # One snapshot writer per machine: the inbox you can see, else a headless
+  # one. The file names the holder's role beside its pid, so an inbox takes
+  # the lock over from a headless process, which it ends, and never from
+  # another inbox; a headless process that finds the lock held exits.
+  class WriterLock
+    DEFAULT_PATH = File.join(Dir.home, ".config", "claude-inbox", "writer.lock")
+    EVICT_TRIES = 20
+
+    def self.disabled = new(path: nil)
+
+    def initialize(path: DEFAULT_PATH)
+      @path = path
+      @file = nil
+    end
+
+    # True once held. Only a headless holder is evicted, and only by an inbox.
+    def take(role:)
+      return true unless @path
+      FileUtils.mkdir_p(File.dirname(@path))
+      file = File.open(@path, File::RDWR | File::CREAT, 0o600)
+      return hold(file, role) if file.flock(File::LOCK_EX | File::LOCK_NB)
+      holder_role, holder = file.read.split
+      return refuse(file) unless role == "inbox" && holder_role == "headless"
+      Process.kill("TERM", holder.to_i) if holder.to_i.positive? && holder.to_i != Process.pid
+      EVICT_TRIES.times do
+        return hold(file, role) if file.flock(File::LOCK_EX | File::LOCK_NB)
+        sleep 0.1
+      end
+      refuse(file)
+    rescue Errno::ESRCH, Errno::EPERM
+      # The holder the file names is gone already: the lock is free.
+      file.flock(File::LOCK_EX | File::LOCK_NB) ? hold(file, role) : refuse(file)
+    end
+
+    private
+
+    # After reading the holder the position sits at the end, and truncate does
+    # not move it, so the write is rewound first or it lands after NUL padding.
+    def hold(file, role)
+      file.rewind
+      file.truncate(0)
+      file.write("#{role} #{Process.pid}")
+      file.flush
+      @file = file # only kept so GC never closes it and drops the flock
+      true
+    end
+
+    def refuse(file)
+      file.close
+      false
+    end
+  end
+end

data/lib/claude_inbox.rb

@@ -1,14 +1,5 @@
 # frozen_string_literal: true
 
 module ClaudeInbox
-  VERSION = "0.3.0"
+  VERSION = "0.5.0"
 end
-
-require_relative "claude_inbox/palette"
-require_relative "claude_inbox/session"
-require_relative "claude_inbox/job_state"
-require_relative "claude_inbox/pull_requests"
-require_relative "claude_inbox/agents_client"
-require_relative "claude_inbox/sessions"
-require_relative "claude_inbox/store"
-require_relative "claude_inbox/reaper"

data/mod/.claude-plugin/plugin.json

@@ -0,0 +1,20 @@
+{
+  "name": "inbox-pane",
+  "version": "0.2.0",
+  "description": "claude-inbox's sections in a pane beside the transcript, with its keys.",
+  "types": "./types/index.d.ts",
+  "userConfig": {
+    "command": {
+      "type": "string",
+      "title": "claude-inbox command",
+      "description": "The claude-inbox executable to run headless when no inbox is writing the snapshot.",
+      "default": "claude-inbox"
+    },
+    "openOnStart": {
+      "type": "boolean",
+      "title": "Open on start",
+      "description": "Open the pane when a session starts. Off, /inbox opens it.",
+      "default": true
+    }
+  }
+}

data/mod/hooks/hooks.json

@@ -0,0 +1 @@
+{ "modules": ["./register.tsx"] }