claude-inbox 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b325ed415502366088de4b6e9b7634835aea1fb0a6be708e211344dfeba8fa33
-  data.tar.gz: 53fbfbeac341e7f5643724911eb5feecb4165a6aaa367dad73c2a4002be9bee9
+  metadata.gz: cea52c058efc847eede80d9633f507fb0bcc88352351d2e8df98d57d531cbd57
+  data.tar.gz: 73953113b090f01dfd646bbcb9295be96d2f6616ecccab116b9f75c2f43f69ed
 SHA512:
-  metadata.gz: 072a5ce3e44c1e5317d105fd49aea27fc5e1365c146c165e8ad87b61b50c24f0046bd659278a41b3848ec15523c1eaa255748f5f080a4e26b25476ba6f7e1218
-  data.tar.gz: 31715b40f83b6749d3064c323018c74f62e1176f248bcc00b3cf16769b81c202b49cb0e7228e3ca8bd3b5519c8d7ca99001c026868d29605b488430a6662f5eb
+  metadata.gz: '080712923012ed2b164ce10dc6e4fbbf511319b7065ee54da07ffac2a6561deb62888f73012d8b7bf1ed3a78ae2d8fae078680fd4102a962bb4a05e345346c77'
+  data.tar.gz: dd9a7ca33067f30d0eb8cb98742bcc229cb981acfdfa0697966d59b43be9cf4c2451a6683378f6389b3226410261d615b9c5fb711df9c1019e659863ca76796c

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/cli.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require "optparse"
+require "tmpdir"
+require_relative "app"
+require_relative "config"
+require_relative "headless"
+require_relative "mod"
+require_relative "updater"
+require_relative "writer_lock"
+
+module ClaudeInbox
+  # What `claude-inbox` does with its arguments: install the pane, update
+  # claude-inbox, or launch the inbox. `run` is true when it succeeded.
+  class CLI
+    USAGE = <<~USAGE
+      Usage: claude-inbox [options]
+             claude-inbox install [--force]
+             claude-inbox update
+    USAGE
+
+    # `lock` stands in for the writer lock a live launch takes.
+    def initialize(argv, env: ENV, config: Config::PATH, lock: nil, out: $stdout)
+      @argv = argv
+      @env = env
+      @config = config
+      @lock = lock
+      @out = out
+    end
+
+    def run
+      case @argv.first
+      when "install" then install
+      when "update" then update
+      else launch
+      end
+    end
+
+    # The launch flags, the config file's before the typed ones. 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.
+    def options
+      @options ||= begin
+        typed = parse(@argv)
+        options = typed[:fixture] ? typed : parse(Config.argv(@argv, path: @config))
+        env = typed[:fixture] ? {} : @env
+        options.merge(listen: Remote::Listener.options(env, flag: options[:listen], modes: options[:allow_modes]))
+      end
+    rescue OptionParser::ParseError, ArgumentError => e
+      abort "claude-inbox: #{e.message}"
+    end
+
+    # The keywords App is built with. A live launch takes the writer lock
+    # here: the first inbox you can see is the snapshot's writer, and a
+    # second one reads along, writing and deleting nothing.
+    def app_options
+      opts = options[:fixture] ? fixture_options : live_options
+      opts[:color] = options[:color]
+      return opts if options[:fixture] || writer_lock.take(role: "inbox")
+      opts.merge(store: Store.new(writable: false, relay: Actions.new), reaper: Reaper.disabled,
+        snapshot: Snapshot.disabled, actions: Actions.disabled, pane_offer: Mod::Offer.disabled)
+    end
+
+    private
+
+    def install
+      force = false
+      subcommand("install") { |p| p.on("--force", "Replace any other copy of the pane") { force = true } }
+      begin
+        installed = Mod.install(force: force)
+      rescue JSON::ParserError
+        abort "claude-inbox: ~/.claude/settings.json is not valid JSON, so it was left alone"
+      end
+      installed.removed.each { |dir| @out.puts "Removed #{dir} from ~/.claude/settings.json." }
+      @out.puts "The pane now runs #{Mod::COMMAND || "claude-inbox from your PATH"}." if installed.command_set
+      @out.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.")
+      true
+    end
+
+    def update
+      subcommand("update")
+      updater = Updater.new
+      begin
+        update = updater.check(force: true)
+      rescue Updater::Error => e
+        abort "claude-inbox: #{e.message}"
+      end
+      unless update
+        @out.puts((updater.kind == :gem) ? "claude-inbox #{VERSION} is the latest release." : "main is up to date.")
+        return true
+      end
+      @out.puts update.installing
+      applied = updater.apply
+      abort "claude-inbox: #{applied.output.strip}" unless applied.success?
+      @out.puts((update.kind == :gem) ? "Installed claude-inbox #{update.latest}." : "main is at #{update.latest}.")
+      true
+    end
+
+    def launch
+      options
+      # Crash traces go here instead of the alt screen when set.
+      $stderr.reopen(@env["CLAUDE_INBOX_STDERR"], "a") if @env["CLAUDE_INBOX_STDERR"]
+      return headless if options[:headless]
+      auto_update if options[:auto_update]
+      # So the pane settings.json names is the installed version's, after a gem update too.
+      Mod.link unless options[:fixture]
+      App.new(**app_options).run
+      true
+    end
+
+    def headless
+      abort "claude-inbox: --headless takes no --fixture" if options[:fixture]
+      Headless.new(client: AgentsClient.new, store: Store.new, updater: updater).run
+    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.
+    def auto_update
+      return unless (update = updater&.cached)
+      @out.puts update.installing
+      applied = updater.apply
+      applied.success? ? updater.relaunch(@argv) : warn("claude-inbox: #{applied.output.strip}")
+    end
+
+    def fixture_options
+      fixtures = File.dirname(options[:fixture])
+      # 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")
+      {client: FixtureClient.new(options[:fixture], logs: File.binread(File.join(fixtures, "logs_raw.txt"))),
+       store: Store.new(path: nil),
+       pull_requests: PullRequests.new(cache_path: File.join(fixtures, "gh-pr-status-cache.json"), resolved_path: nil, gh: nil),
+       listen: options[:listen]&.merge(fixture: true, pairing: Remote::Pairing.new(path: File.join(dir, "listen.json")),
+         lock_path: File.join(dir, "listen.lock"), images_dir: File.join(dir, "images"))}
+    end
+
+    # 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 here, and only when asked for.
+    def live_options
+      client = AgentsClient.new
+      store = Store.new
+      {client: client, store: store, reaper: options[:reap] ? Reaper.new(client, store) : Reaper.disabled,
+       snapshot: Snapshot.new, switch: Switch.new, actions: Actions.new, pane_offer: Mod::Offer.new,
+       listen: options[:listen], updater: updater,
+       # The typed arguments, not the config's: a relaunch reads the config again.
+       argv: @argv}
+    end
+
+    def updater
+      @updater ||= Updater.new if options[:update_check] && !options[:fixture]
+    end
+
+    # Held for the life of this process by this reference.
+    def writer_lock = (@lock ||= WriterLock.new)
+
+    def parse(argv)
+      opts = {color: true, update_check: true}
+      parser = OptionParser.new(USAGE) do |p|
+        p.on("--version", "Print the version") {
+          @out.puts VERSION
+          exit
+        }
+        p.on("--mod-dir", "Print the pane's directory, for CLAUDE_CODE_PLUGIN_DIRS") {
+          @out.puts Mod.link(force: true)
+          exit
+        }
+        p.on("--fixture PATH", "Read sessions from an agents.json instead of the daemon") { |path| opts[:fixture] = path }
+        p.on("--headless", "Keep the pane's snapshot fresh without a screen") { opts[:headless] = true }
+        p.on("--reap", "Delete background sessions idle 14 days") { opts[:reap] = true }
+        p.on("--no-color", "Draw without color") { opts[:color] = false }
+        p.on("--auto-update", "Install a release found today before launching") { opts[:auto_update] = true }
+        p.on("--no-update-check", "Never look for a newer release") { opts[:update_check] = false }
+        # --listen-lan wins over --listen, whichever came last.
+        p.on("--listen[=PORT]", "Let a phone on this Mac start sessions") { |port| opts[:listen] = {lan: false, port: port} unless opts.dig(:listen, :lan) }
+        p.on("--listen-lan[=PORT]", "Let a phone on your network start sessions") { |port| opts[:listen] = {lan: true, port: port} }
+        p.on("--listen-allow-modes=MODES", "The permission modes a phone may start in") { |modes| opts[:allow_modes] = modes }
+      end
+      strictly(parser, argv)
+      opts
+    end
+
+    def subcommand(name)
+      parser = OptionParser.new(USAGE)
+      yield parser if block_given?
+      strictly(parser, @argv.drop(1))
+    rescue OptionParser::ParseError => e
+      abort "claude-inbox #{name}: #{e.message}"
+    end
+
+    # Exact names only, so a typo is an error rather than the flag it abbreviates.
+    def strictly(parser, argv)
+      parser.require_exact = true
+      rest = parser.parse(argv)
+      raise OptionParser::InvalidArgument, rest.first if rest.any?
+    end
+  end
+end

data/lib/claude_inbox/job_state.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "json"
+require "time"
 
 module ClaudeInbox
   # What the daemon writes about a background session in
@@ -16,7 +17,7 @@ module ClaudeInbox
   # `output.result` what it produced once done. It also carries the PR links the daemon scanned out of the
   # transcript, which PullRequests reads through here, the color `/color`
   # set on the session, which `claude agents --json` drops, and `intent`, the
-  # prompt the session was started from.
+  # prompt the session was started from, and `createdAt`, when it was.
   #
   # Never cached. A color changes the moment you type `/color`, so every poll
   # asks the file again.
@@ -64,7 +65,7 @@ module ClaudeInbox
       nil
     end
 
-    attr_reader :pr_urls, :color, :intent, :bridge_id
+    attr_reader :pr_urls, :color, :intent, :bridge_id, :created_at
 
     def initialize(hash)
       @detail = hash["detail"]
@@ -77,6 +78,7 @@ module ClaudeInbox
       @color = hash["color"]
       @intent = hash["intent"]
       @bridge_id = hash["bridgeSessionId"]
+      @created_at = time(hash["createdAt"])
       @flags = hash["respawnFlags"] || []
     end
 
@@ -122,5 +124,11 @@ module ClaudeInbox
     def count_label = "#{tasks} #{plural("task", tasks)}"
 
     def plural(word, n) = (n == 1) ? word : "#{word}s"
+
+    def time(iso)
+      iso && Time.iso8601(iso)
+    rescue ArgumentError
+      nil
+    end
   end
 end

data/lib/claude_inbox/remote/listener.rb

@@ -67,13 +67,12 @@ module ClaudeInbox
       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.
-      def self.options(argv, env)
-        flags = argv.filter_map { |arg| arg.match(/\A--listen(-lan)?(?:=(.*))?\z/) }
+      # asks for it. `flag` is the listen flag's `lan:` and `port:`, and
+      # `modes` --listen-allow-modes, both as typed.
+      def self.options(env, flag: nil, modes: nil)
         lan, port =
-          if flags.any?
-            flag = flags.reverse.find { |m| m[1] } || flags.last
-            [!flag[1].nil?, flag[2]]
+          if flag
+            flag.values_at(:lan, :port)
           elsif !(value = env["CLAUDE_INBOX_LISTEN"].to_s.strip).empty?
             m = value.match(/\A(?:(lan)(?::(.*))?|(\d+))\z/i)
             raise ArgumentError, "CLAUDE_INBOX_LISTEN is a port, lan or lan:PORT, not #{value}" unless m
@@ -81,7 +80,7 @@ module ClaudeInbox
           else
             return nil
           end
-        modes = argv.filter_map { |arg| arg[/\A--listen-allow-modes=(.*)\z/, 1] }.last || env["CLAUDE_INBOX_LISTEN_ALLOW_MODES"]
+        modes ||= env["CLAUDE_INBOX_LISTEN_ALLOW_MODES"]
         {port: port_option(port), lan: lan, allowed_modes: modes_option(modes)}
       end
 

data/lib/claude_inbox/session.rb

@@ -78,6 +78,10 @@ module ClaudeInbox
     # From `/color`; interactive sessions have no job file, so never one.
     def color = job_state&.color
 
+    # A respawn moves `started_at` to the new process; the job file keeps
+    # when the session itself began.
+    def created_at = job_state&.created_at || started_at
+
     # The prompt this session was started with.
     def intent = job_state&.intent
 

data/lib/claude_inbox/store/row.rb

@@ -71,7 +71,7 @@ module ClaudeInbox
       def settled?
         return true if hand_settled?
         return false if UNSETTLEABLE.include?(session.effective_state)
-        started = session.started_at.to_i
+        started = session.created_at.to_i
         ours = session.prs.select(&:known?).reject { |pr| pr.resolved_before?(started) }
         ours.any? && ours.all? { |pr| pr.resolved_since?(started) }
       end

data/lib/claude_inbox.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ClaudeInbox
-  VERSION = "0.6.0"
+  VERSION = "0.6.1"
 end

data/mod/hooks/register.tsx

@@ -197,14 +197,20 @@ async function requestSwitch($: EngineInterface, host: Host, id: string): Promis
   })
 }
 
-// The pane keeps the keys while its session is away, so coming back to it would put the
-// person's typing in the pane. The engine has no blur: reopening without `focus` is the
-// one way to give the keys to the prompt.
+// Every key that takes the person out of the pane, to another session or the browser, calls
+// this first: the pane would keep the keys while they are away, and their typing on coming
+// back would land in it. The engine has no blur: reopening without `focus` is the one way
+// to give the keys to the prompt.
 async function handBackKeys($: EngineInterface): Promise<void> {
   await $.ui.close({ id: PANE })
   await $.ui.open(OPEN)
 }
 
+async function openInBrowser($: EngineInterface, url: string): Promise<void> {
+  await handBackKeys($)
+  await $.process.run(['open', url])
+}
+
 // Only while no inbox writes the snapshot; the gem's writer lock turns a second one away.
 function startHeadless($: EngineInterface, host: Host, now: number): void {
   if (host.isHeadlessRunning || now - host.headlessStartedAt < RESTART_S) return
@@ -410,8 +416,8 @@ export const register: Register = (on, options) => {
                     $.ui.toast(copied.isCopied ? `copied: claude attach ${row.id}` : 'no clipboard here'),
                   )
                 }),
-                key('o', () => (row?.pr ? void $.process.run(['open', row.pr.url]) : $.ui.toast('no pull request linked'))),
-                key('w', () => (row?.remote ? void $.process.run(['open', row.remote]) : $.ui.toast('no claude.ai/code page for this session'))),
+                key('o', () => (row?.pr ? void openInBrowser($, row.pr.url) : $.ui.toast('no pull request linked'))),
+                key('w', () => (row?.remote ? void openInBrowser($, row.remote) : $.ui.toast('no claude.ai/code page for this session'))),
                 key('q', () => void $.ui.close({ id: PANE })),
               ]
 

data/mod/tests/pane.test.tsx

@@ -220,6 +220,38 @@ test('a switch hands the keys back to the prompt before it asks, so a return lan
   await ui.unmount()
 })
 
+test('o and w hand the keys back to the prompt before they open the browser', async ($, on) => {
+  mock.env(on, { HOME: '/Users/me' })
+  mock.clock(on, { now: 1_700_000_000_000 })
+  const remote = { ...ROWS[1], remote: 'https://claude.ai/code/session_b2' }
+  on('state.get', ($, e, next) => (e.key === 'rows' ? seeded([remote]) : e.key === 'writtenAt' ? seeded(1_700_000_000) : next(e)))
+  const calls: string[] = []
+  on('ui.close', ($, e) => {
+    calls.push(`close ${e.id}`)
+    return { value: undefined }
+  })
+  on('ui.open', ($, e) => {
+    calls.push(`open ${e.id}${e.focus ? ' focused' : ''}`)
+    return { value: { isPlaced: true } }
+  })
+  on('process.run', ($, e) => {
+    calls.push(e.argv.join(' '))
+    return { value: { code: 0, stdout: '', stderr: '' } }
+  })
+  const ui = await $.ui.mount({ ...PANE, surface: 'terminal' })
+  await ui.press({ key: 'o' })
+  await ui.press({ key: 'w' })
+  expect(calls).toEqual([
+    'close inbox',
+    'open inbox',
+    'open https://github.com/o/r/pull/7',
+    'close inbox',
+    'open inbox',
+    'open https://claude.ai/code/session_b2',
+  ])
+  await ui.unmount()
+})
+
 test('a click on a row puts the cursor on it before it asks for the switch', async ($, on) => {
   mock.env(on, { HOME: '/Users/me' })
   mock.clock(on, { now: 1_700_000_000_000 })

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: claude-inbox
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Jordan Byron
@@ -108,6 +108,7 @@ files:
 - lib/claude_inbox/actions.rb
 - lib/claude_inbox/agents_client.rb
 - lib/claude_inbox/app.rb
+- lib/claude_inbox/cli.rb
 - lib/claude_inbox/config.rb
 - lib/claude_inbox/debug.rb
 - lib/claude_inbox/dialog.rb