claude-inbox 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b325ed415502366088de4b6e9b7634835aea1fb0a6be708e211344dfeba8fa33
-  data.tar.gz: 53fbfbeac341e7f5643724911eb5feecb4165a6aaa367dad73c2a4002be9bee9
+  metadata.gz: b432b1272fd3e3b923eaefe34fa4e3c30cbd9dfcf57d4beacd761f1cef70785b
+  data.tar.gz: '090ff2d41f9701cc7476196af19e4604241b3b3079376a896b441ab9dbf0ce9d'
 SHA512:
-  metadata.gz: 072a5ce3e44c1e5317d105fd49aea27fc5e1365c146c165e8ad87b61b50c24f0046bd659278a41b3848ec15523c1eaa255748f5f080a4e26b25476ba6f7e1218
-  data.tar.gz: 31715b40f83b6749d3064c323018c74f62e1176f248bcc00b3cf16769b81c202b49cb0e7228e3ca8bd3b5519c8d7ca99001c026868d29605b488430a6662f5eb
+  metadata.gz: a075eee59befc0de0e667d5b4325db8086a457040d544534f75b62d8a05b91a5e703b370bd1f3ce52fe89638cefa93403b1d6acd7170f143a86111a9d4c75277
+  data.tar.gz: 1d3dbb6ead15764e91834af2de5b8cfa9873493830e0cf2cee6080a4884fe3d74476b2a260b47565f6e70c99f5611d9c57bb422950435b80cc90b12eb55bc859

data/README.md

@@ -73,10 +73,8 @@ Vim bindings. Arrows and the mouse work too.
 | `Ctrl-d` `Ctrl-u` | half page down / up (`Ctrl-f` `Ctrl-b` full page) |
 | `Enter` `l` | attach (`←` or `Ctrl+Z` returns here), adopt a remote session, or expand Snoozed / Settled |
 | `Tab` `Shift+Tab` | next / previous section |
-| `h` | close the peek pane, else collapse the current fold |
+| `h` | collapse the current fold |
 | `za` `zo` `zc` | toggle / open / close the fold under the cursor |
-| `p` | toggle the read-only peek pane |
-| `J` `K` (`Ctrl-e` `Ctrl-y`) | scroll the peek pane |
 | `n` | new session |
 | `N` | pair a phone |
 | `t` | pin / unpin |

data/exe/claude-inbox

@@ -2,129 +2,6 @@
 # frozen_string_literal: true
 
 require "claude_inbox"
+require "claude_inbox/cli"
 
-if ARGV.include?("--version")
-  puts ClaudeInbox::VERSION
-  exit
-end
-
-require "claude_inbox/mod"
-
-# The stable path to the Claude Code pane, for CLAUDE_CODE_PLUGIN_DIRS.
-if ARGV.include?("--mod-dir")
-  puts ClaudeInbox::Mod.link(force: true)
-  exit
-end
-
-if ARGV.first == "install"
-  begin
-    installed = ClaudeInbox::Mod.install(force: ARGV.include?("--force"))
-  rescue JSON::ParserError
-    abort "claude-inbox: ~/.claude/settings.json is not valid JSON, so it was left alone"
-  end
-  installed.removed.each { |dir| puts "Removed #{dir} from ~/.claude/settings.json." }
-  puts "The pane now runs #{ClaudeInbox::Mod::COMMAND || "claude-inbox from your PATH"}." if installed.command_set
-  puts installed.added ? "Added the pane to ~/.claude/settings.json. New Claude Code sessions load it; /inbox opens it." :
-    "The pane is already in ~/.claude/settings.json."
-  exit
-end
-
-if ARGV.first == "update"
-  require "claude_inbox/updater"
-  updater = ClaudeInbox::Updater.new
-  begin
-    update = updater.check(force: true)
-  rescue ClaudeInbox::Updater::Error => e
-    abort "claude-inbox: #{e.message}"
-  end
-  unless update
-    puts((updater.kind == :gem) ? "claude-inbox #{ClaudeInbox::VERSION} is the latest release." : "main is up to date.")
-    exit
-  end
-  puts update.installing
-  applied = updater.apply
-  abort "claude-inbox: #{applied.output.strip}" unless applied.success?
-  puts((update.kind == :gem) ? "Installed claude-inbox #{update.latest}." : "main is at #{update.latest}.")
-  exit
-end
-
-require "claude_inbox/app"
-require "claude_inbox/config"
-require "claude_inbox/updater"
-require "claude_inbox/writer_lock"
-require "tmpdir"
-
-fixture = ARGV.include?("--fixture")
-# A fixture run takes the listen flags, for trying the API with curl, but
-# not the environment or the config file, which are for the real inbox.
-begin
-  argv = fixture ? ARGV : ClaudeInbox::Config.argv(ARGV)
-  listen = ClaudeInbox::Remote::Listener.options(argv, fixture ? {} : ENV)
-rescue ArgumentError => e
-  abort "claude-inbox: #{e.message}"
-end
-
-# Crash traces go here instead of the alt screen when set.
-$stderr.reopen(ENV["CLAUDE_INBOX_STDERR"], "a") if ENV["CLAUDE_INBOX_STDERR"]
-
-opts = {}
-if fixture
-  agents = argv[argv.index("--fixture") + 1]
-  fixtures = File.dirname(agents)
-  opts[:client] = ClaudeInbox::FixtureClient.new(agents, logs: File.binread(File.join(fixtures, "logs_raw.txt")))
-  opts[:store] = ClaudeInbox::Store.new(path: nil)
-  opts[:pull_requests] = ClaudeInbox::PullRequests.new(cache_path: File.join(fixtures, "gh-pr-status-cache.json"), resolved_path: nil, gh: nil)
-  # Its own token, lock and images, so a test inbox can neither rotate the
-  # token phones are paired with nor hold the real inbox's lock.
-  dir = File.join(Dir.tmpdir, "claude-inbox-fixture")
-  opts[:listen] = listen&.merge(fixture: true, pairing: ClaudeInbox::Remote::Pairing.new(path: File.join(dir, "listen.json")),
-    lock_path: File.join(dir, "listen.lock"), images_dir: File.join(dir, "images"))
-else
-  # The only place the reaper is armed, and only with --reap: deleting
-  # sessions is opt-in. Everything else — tests, --fixture, anything
-  # embedding App — gets one that deletes nothing. The listener, likewise,
-  # comes only from this file, and only when asked for.
-  opts[:client] = ClaudeInbox::AgentsClient.new
-  opts[:store] = ClaudeInbox::Store.new
-  opts[:reaper] = argv.include?("--reap") ? ClaudeInbox::Reaper.new(opts[:client], opts[:store]) : ClaudeInbox::Reaper.disabled
-  opts[:snapshot] = ClaudeInbox::Snapshot.new
-  opts[:switch] = ClaudeInbox::Switch.new
-  opts[:actions] = ClaudeInbox::Actions.new
-  opts[:pane_offer] = ClaudeInbox::Mod::Offer.new
-  opts[:listen] = listen
-  opts[:updater] = ClaudeInbox::Updater.new unless argv.include?("--no-update-check")
-  # The typed arguments, not the config's: a relaunch reads the config again.
-  opts[:argv] = ARGV
-end
-opts[:color] = false if argv.include?("--no-color")
-
-if argv.include?("--headless")
-  abort "claude-inbox: --headless takes no --fixture" if fixture
-  require "claude_inbox/headless"
-  exit(ClaudeInbox::Headless.new(client: opts[:client], store: opts[:store], updater: opts[:updater]).run ? 0 : 1)
-end
-
-# Only what a check within the day already found: a cold launch never waits
-# on the network. The relaunch is the new version's launch; a failure leaves
-# this one to start as usual.
-if argv.include?("--auto-update") && (update = opts[:updater]&.cached)
-  puts update.installing
-  applied = opts[:updater].apply
-  applied.success? ? opts[:updater].relaunch(ARGV) : warn("claude-inbox: #{applied.output.strip}")
-end
-
-# The first inbox you can see is the snapshot's writer: a headless one gives
-# way to it, and a second inbox reads along, writing and deleting nothing.
-# Held for the life of this process by this reference.
-writer_lock = fixture ? ClaudeInbox::WriterLock.disabled : ClaudeInbox::WriterLock.new
-unless writer_lock.take(role: "inbox")
-  opts[:store] = ClaudeInbox::Store.new(writable: false, relay: ClaudeInbox::Actions.new)
-  opts[:reaper] = ClaudeInbox::Reaper.disabled
-  opts[:snapshot] = ClaudeInbox::Snapshot.disabled
-  opts[:actions] = ClaudeInbox::Actions.disabled
-  opts[:pane_offer] = ClaudeInbox::Mod::Offer.disabled
-end
-# So the pane settings.json names is the installed version's, after a gem update too.
-ClaudeInbox::Mod.link unless fixture
-
-ClaudeInbox::App.new(**opts).run
+exit ClaudeInbox::CLI.new(ARGV).run

data/lib/claude_inbox/agents_client.rb

@@ -27,13 +27,6 @@ module ClaudeInbox
       classify_origins(parse(r.out))
     end
 
-    # Raw terminal replay for a session, or nil when the daemon can't serve it
-    # (finished sessions whose process is gone report "job not found").
-    def logs(id)
-      r = Subprocess.capture(@bin, "logs", id)
-      (r.success? && !r.out.empty?) ? r.out : nil
-    end
-
     # Poll interval for the agents-view watchdog below.
     WATCH_INTERVAL = 0.05
 
@@ -259,10 +252,9 @@ module ClaudeInbox
 
   # Reads a committed JSON fixture instead of the daemon.
   class FixtureClient < AgentsClient
-    def initialize(path, logs: nil, origins: {}, bridges: {})
+    def initialize(path, origins: {}, bridges: {})
       super(jobs_dir: File.join(File.dirname(path), "jobs"))
       @path = path
-      @logs = logs
       @origins = origins
       @bridges = bridges
     end
@@ -274,8 +266,6 @@ module ClaudeInbox
       assign_origins(parse(File.read(@path)), @origins, @bridges)
     end
 
-    def logs(_id) = @logs
-
     # Stand-in child: prints, waits for a line, exits — enough to prove the
     # terminal round-trips through cooked mode and back.
     def attach(id) = system("sh", "-c", "printf 'fake attach to %s\\npress enter to detach: ' \"$1\"; read -r _", "attach", id)

data/lib/claude_inbox/app/attaching.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module ClaudeInbox
+  class App
+    # Handing the terminal to a session and getting it back, and asking the
+    # daemon to stop or delete one.
+    module Attaching
+      private
+
+      def activate
+        return set_expanded(true) if @selected&.fold?
+        return @modal = Dialog::Confirm.new(:adopt, @selected.key) if selected_session&.remote?
+        attach(@selected.key) if require_actionable
+      end
+
+      # Guard for attach/stop: refuse politely on a terminal or remote row.
+      def require_actionable
+        s = selected_session
+        return true if s&.actionable?
+        if s&.interactive?
+          notice(s.remote? ? "that's a remote session — Enter adopts it, w opens it at claude.ai/code" : "that's your own terminal — switch to that window")
+        end
+        false
+      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)
+        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
+
+      def adopt_session(key)
+        s = session_for(key)
+        return unless s&.remote?
+        notice("adopting #{s.display_name}…")
+        in_background do
+          id = @client.adopt(session_id: s.session_id, cwd: s.cwd, pid: s.pid)
+          @queue << [:notice, "adopted as #{id}"]
+          @queue << [:select, id]
+          @queue << [:attach, id]
+        end
+      end
+
+      def open_confirm(kind)
+        return unless require_actionable
+        @modal = Dialog::Confirm.new(kind, @selected.key)
+      end
+
+      def stop_session(id)
+        in_background do
+          @client.stop(id)
+          @poller.soon
+        end
+      end
+
+      def delete_session(id)
+        notice("deleting #{id}…")
+        in_background do
+          @client.rm(id)
+          @store.forget(id)
+          @queue << [:notice, "deleted #{id}"]
+          @poller.soon
+        end
+      end
+    end
+  end
+end

data/lib/claude_inbox/app/browsing.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ClaudeInbox
+  class App
+    # o opens the selected session's pull request and w its claude.ai/code
+    # page, through whatever opens URLs on this platform.
+    module Browsing
+      private
+
+      def open_pr
+        pr = selected_session&.pr
+        return notice("no pull request linked — P sets one") unless pr
+        open_in_browser(pr.url, pr.short)
+      end
+
+      def open_remote
+        url = selected_session&.remote_url
+        return notice("no claude.ai/code page for this session") unless url
+        open_in_browser(url, "claude.ai/code")
+      end
+
+      def open_in_browser(url, what)
+        opener = RUBY_PLATFORM.include?("darwin") ? "open" : "xdg-open"
+        notice("opening #{what}")
+        in_background { Subprocess.capture(opener, url) }
+      end
+    end
+  end
+end

data/lib/claude_inbox/app/filtering.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ClaudeInbox
+  class App
+    # The `/` filter line and the sections that match it.
+    module Filtering
+      private
+
+      def filter_editing? = @filter_editing
+
+      def filter = @filter
+
+      def filtered(sections = @store.sections) = sections.matching(@filter&.to_s)
+
+      def start_filter
+        @filter ||= TextBuffer.new
+        @filter_editing = true
+      end
+
+      def clear_filter
+        @filter = nil
+        @filter_editing = false
+      end
+
+      def handle_line_key(name, key)
+        case name
+        when :escape then clear_filter
+        when :return, :enter then @filter_editing = false
+        when :backspace, :ctrl_h
+          @filter.empty? ? clear_filter : @filter.press(name, key)
+        else
+          @filter.press(name, key)
+        end
+      end
+    end
+  end
+end

data/lib/claude_inbox/app/navigating.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module ClaudeInbox
+  class App
+    # Where the cursor is in the sectioned, foldable list and how it moves.
+    # The only writer of the selection; the rest of App reads it.
+    module Navigating
+      private
+
+      # Remembers where the frame put the rows, so a click can find one.
+      def placed(frame)
+        @row_items = frame.items
+        @top = frame.top
+      end
+
+      # The row to land on once a poll lists it, as after a spawn.
+      def select_later(id)
+        @pending_select = id
+      end
+
+      def ensure_selection(sections)
+        stops = sections.selections(@expanded)
+        pending = @pending_select && Store::Selection.row(@pending_select)
+        if pending && stops.include?(pending)
+          select(pending)
+          @pending_select = nil
+          return
+        end
+        return if stops.include?(@selected)
+        select(stops.first)
+      end
+
+      def select(selection)
+        @selected = selection
+      end
+
+      def session_for(key) = @store.sessions.find { |s| s.key == key }
+
+      def selected_session = session_for(@selected&.key)
+
+      def page = [Renderer.body_height(@terminal.size[1]), 1].max
+
+      def move(delta)
+        stops = filtered.selections(@expanded)
+        return if stops.empty?
+        idx = stops.index(@selected) || 0
+        select(stops[(idx + delta).clamp(0, stops.size - 1)])
+      end
+
+      # Tab / Shift-Tab: first selectable row of the next / previous section.
+      def jump_section(dir)
+        sections = filtered
+        heads = sections.heads(@expanded)
+        return if heads.empty?
+        current = sections.section_of(@selected)
+        idx = heads.index { |name, _| name == current } || -1
+        select(heads[(idx + dir) % heads.size].last)
+      end
+
+      # The foldable section the cursor is currently on or inside, if any.
+      def current_fold_section
+        name = filtered.section_of(@selected)
+        name if Store::FOLDABLE_SECTIONS.include?(name)
+      end
+
+      def set_expanded(value)
+        name = current_fold_section
+        @expanded[name] = value if name
+      end
+
+      def toggle_expanded = set_expanded(!@expanded[current_fold_section])
+
+      # Clicking a row selects it and attaches, same as landing on it with
+      # j/k and pressing Enter — activate already knows how to expand a fold
+      # or refuse a terminal/remote row, so this doesn't repeat that.
+      def click_row(row)
+        item = row_item_at(row)
+        return unless item
+        select(item)
+        activate
+      end
+
+      # The wrapped detail line under a two-line row ("↳ ~/code/x") carries
+      # 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]&.row?)
+      end
+    end
+  end
+end

data/lib/claude_inbox/app/spawning.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module ClaudeInbox
+  class App
+    # Starting a session, from the `n` form here or from another device.
+    module Spawning
+      private
+
+      def open_new_session
+        cwd = selected_session&.cwd || Dir.pwd
+        dirs = SessionRequest.directories(@store.sessions, @trust.call)
+        @modal = NewSessionForm.new(cwd: SessionRequest.strip_worktree(cwd), color: @color, dirs: dirs)
+      end
+
+      # `:start`/`:start_and_attach` leave the form as `@modal`, now busy: it
+      # closes itself once the spawn is confirmed to have started (`:form_started`)
+      # or reopens with the failure and the prompt intact (`:form_failed`).
+      def handle_form_key(name, key)
+        form = @modal
+        case form.press(name, key)
+        when :cancel then @modal = nil
+        when :start then start_session(form, attach: false)
+        when :start_and_attach then start_session(form, attach: true)
+        end
+      end
+
+      # `attach:` hands the terminal over as soon as the session starts. Without
+      # it we stay in the inbox and poll, so the new row shows up right away
+      # rather than at the next tick.
+      def start_session(form, attach:)
+        v = form.values
+        notice("starting session…")
+        in_background do
+          id = @client.spawn(**v)
+          @queue << [:notice, "started #{id}"]
+          @queue << [:form_started, form]
+          @queue << [:select, id]
+          attach ? @queue << [:attach, id] : @poller.soon
+        rescue AgentsClient::Error => e
+          @queue << [:form_failed, form, e.message]
+        end
+      end
+
+      def form_started(form)
+        @modal = nil if @modal.equal?(form)
+      end
+
+      # A spawn failure hands the form back rather than just logging it, so
+      # the composed prompt survives (see NewSessionForm#submission_failed).
+      def form_failed(form, message)
+        @modal.equal?(form) ? form.submission_failed(message) : (@error = message)
+      end
+
+      # Someone at the desk may be mid-thought, so a start from another
+      # device never moves the cursor, attaches or closes what is open.
+      def remote_started(id, via)
+        notice("started #{id} from #{via}")
+        @poller.soon
+      end
+    end
+  end
+end

data/lib/claude_inbox/app/triaging.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module ClaudeInbox
+  class App
+    # The edits of the selected row that live in our own store, and the two
+    # guards they share.
+    module Triaging
+      private
+
+      # Guard for snooze/wake/alias: anything with a key, since those live in
+      # our own store. A terminal you are sitting in is the one exception.
+      def require_storable
+        s = selected_session
+        return true if @selected&.row? && !s&.terminal?
+        notice("you're in that terminal right now — nothing to snooze") if s&.terminal?
+        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 wake_selected
+        @store.wake(@selected.key) if require_storable
+      end
+
+      def toggle_pin_selected
+        @store.toggle_pin(@selected.key) if require_storable
+      end
+
+      def settle_selected
+        return unless require_storable
+        @store.settle(@selected.key)
+        notice("settled — u brings it back")
+      end
+
+      def open_snooze_menu
+        return unless require_storable
+        @modal = Dialog::Snooze.new(@selected.key)
+      end
+
+      def snooze_chosen
+        @store.snooze(@modal.id, @modal.choice)
+        @modal = nil
+      end
+
+      def open_alias_editor
+        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 && 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
+
+      def save_prompt
+        value = @modal.value.strip
+        if @modal.kind == :alias
+          @store.set_alias(@modal.id, value)
+        elsif value.empty? || PullRequests.valid_url?(value)
+          @store.set_pr(@modal.id, value)
+          @poller.soon
+        else
+          return notice("that's not a github.com pull request url")
+        end
+        @modal = nil
+      end
+    end
+  end
+end

data/lib/claude_inbox/app/updating.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ClaudeInbox
+  class App
+    # The newer-release check, the header's word on it, and U to install
+    # and relaunch.
+    module Updating
+      private
+
+      # Once, on the first step: a stale cache means a network round trip, so
+      # it runs off the main thread. A laptop that is offline stays quiet
+      # rather than show an error at every launch; U says what went wrong.
+      def ensure_update_checked
+        return if @update_status
+        @update_status = @updater ? "checking for updates…" : "update check is off — claude-inbox update installs the latest"
+        return unless @updater
+        in_background do
+          @queue << [:update, @updater.check]
+        rescue Updater::Error => e
+          @queue << [:update, nil, e.message]
+        end
+      end
+
+      def update_checked(update, failure = nil)
+        @update = update
+        @snapshot.update = update&.notice
+        @update_status = failure ? "couldn't check for updates: #{failure}" : "up to date"
+      end
+
+      # The header's line once a newer release is known; nil until then.
+      def update_notice
+        "#{@update.notice} · U updates" if @update
+      end
+
+      # The install prints on the real screen, and the relaunch replaces this
+      # process. A failed install relaunches this version instead, once its
+      # error has been read, rather than leave the shell showing.
+      def update_inbox
+        return notice(@update_status) unless @update
+        @terminal.release do
+          @out.puts @update.installing
+          applied = @updater.apply
+          @out.puts applied.output unless applied.output.empty?
+          @terminal.pause unless applied.success?
+          relaunch
+        end
+      end
+
+      def relaunch
+        @updater.relaunch(@argv)
+      rescue SystemCallError => e
+        @error = "relaunch failed: #{e.message}"
+      end
+    end
+  end
+end