claude-inbox 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cea52c058efc847eede80d9633f507fb0bcc88352351d2e8df98d57d531cbd57
-  data.tar.gz: 73953113b090f01dfd646bbcb9295be96d2f6616ecccab116b9f75c2f43f69ed
+  metadata.gz: b432b1272fd3e3b923eaefe34fa4e3c30cbd9dfcf57d4beacd761f1cef70785b
+  data.tar.gz: '090ff2d41f9701cc7476196af19e4604241b3b3079376a896b441ab9dbf0ce9d'
 SHA512:
-  metadata.gz: '080712923012ed2b164ce10dc6e4fbbf511319b7065ee54da07ffac2a6561deb62888f73012d8b7bf1ed3a78ae2d8fae078680fd4102a962bb4a05e345346c77'
-  data.tar.gz: dd9a7ca33067f30d0eb8cb98742bcc229cb981acfdfa0697966d59b43be9cf4c2451a6683378f6389b3226410261d615b9c5fb711df9c1019e659863ca76796c
+  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/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