claude-inbox 0.2.0 → 0.4.0

data/lib/claude_inbox/pull_requests.rb

@@ -1,14 +1,16 @@
 # frozen_string_literal: true
 
 require "json"
+require "time"
 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
+  # or nil when nothing has told us yet. `resolved_at` is when it was merged
+  # or closed, in epoch seconds, once gh has said.
+  PullRequest = Struct.new(:number, :url, :state, :title, :resolved_at) do
     def short = number ? "##{number}" : url.to_s.sub(%r{\Ahttps?://(www\.)?}, "")
 
     def merged? = state == "MERGED"
@@ -19,6 +21,16 @@ module ClaudeInbox
     def resolved? = merged? || closed?
 
     def known? = !state.nil?
+
+    # Nothing more to learn: resolved, and gh has said when.
+    def final? = resolved? && !resolved_at.nil?
+
+    # Resolved before `time`, so a session started then can only have mentioned it.
+    def resolved_before?(time) = final? && resolved_at < time.to_i
+
+    # Resolved at or after `time`, which is the only kind of resolution that
+    # can answer a session started then.
+    def resolved_since?(time) = final? && resolved_at >= time.to_i
   end
 
   # Finds the PRs a session is tied to and keeps their state fresh.
@@ -34,11 +46,10 @@ module ClaudeInbox
   # 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.
+  # REFRESH_AFTER. A merged or closed PR never changes again, so once gh has
+  # said so, and when, it is written to RESOLVED_PATH and never asked about
+  # again. Claude Code's cache never says when, and says nothing at all about
+  # most of a link scan's PRs: it only covers PRs its own sessions opened.
   #
   # `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
@@ -73,32 +84,28 @@ module ClaudeInbox
     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.
+    # sessions with the answers on their `prs` and whether any PR changed, so
+    # the caller knows whether the list is worth publishing again. A merge
+    # date alone counts: it is what lets a PR the cache called merged settle.
     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 }
+          status(pr.url).tap { |now| changed = true if now != pr }
         })
       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)
+        return pr if pr.final? || !due?(url)
         @checked_at[url] = @clock.call.to_i
         fresh = fetch(url)
         return pr unless fresh
-        remember(fresh) if fresh.resolved?
+        remember(fresh) if fresh.final?
         @known[url] = fresh
       end
     end
@@ -107,8 +114,9 @@ module ClaudeInbox
     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
+      resolved_at = h["closedAt"] && Time.iso8601(h["closedAt"]).to_i
+      PullRequest.new(number: h["number"], url: h["url"] || url, state: state, title: h["title"], resolved_at: resolved_at)
+    rescue JSON::ParserError, ArgumentError
       nil
     end
 
@@ -119,6 +127,11 @@ module ClaudeInbox
 
     private
 
+    # Best known state for a url without asking gh.
+    def known(url)
+      @mutex.synchronize { @known[url] ||= seed(url) }
+    end
+
     def due?(url)
       @gh && @clock.call.to_i - @checked_at.fetch(url, 0) >= REFRESH_AFTER
     end
@@ -126,7 +139,8 @@ module ClaudeInbox
     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"))
+      PullRequest.new(number: cached&.dig("number") || number, url: url, state: cached&.dig("state"),
+        title: cached&.dig("title"), resolved_at: cached&.dig("resolved_at"))
     end
 
     # Same shape as Claude Code's cache, so `seed` reads both alike.
@@ -140,13 +154,13 @@ module ClaudeInbox
 
     # Under @mutex.
     def remember(pr)
-      resolved[pr.url] = {"number" => pr.number, "state" => pr.state, "title" => pr.title}
+      resolved[pr.url] = {"number" => pr.number, "state" => pr.state, "title" => pr.title, "resolved_at" => pr.resolved_at}
       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 = Subprocess.capture(@gh, "pr", "view", url, "--json", "number,state,isDraft,title,url,closedAt")
       r.success? ? self.class.parse(url, r.out) : nil
     rescue SystemCallError
       nil

data/lib/claude_inbox/rate_limits.rb

@@ -18,9 +18,7 @@ module ClaudeInbox
     LABELS = {"five_hour" => "session", "seven_day" => "week"}.freeze
 
     # `resets_at` is when the window rolls over, or nil if the file omits it.
-    Window = Data.define(:label, :percent, :resets_at) do
-      def initialize(label:, percent:, resets_at: nil) = super
-    end
+    Window = Data.define(:label, :percent, :resets_at)
 
     def initialize(path: DEFAULT_PATH)
       @path = path

data/lib/claude_inbox/records.rb

@@ -18,10 +18,15 @@ module ClaudeInbox
       {}
     end
 
-    def save(path, data)
+    # `perm` is set on the temp file before anything is written to it, so
+    # a secret is never readable at a wider mode, not even briefly.
+    def save(path, data, perm: nil)
       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.open(tmp, "w", perm || 0o666) do |f|
+        f.chmod(perm) if perm
+        f.write(JSON.pretty_generate(data))
+      end
       File.rename(tmp, path)
     end
   end

data/lib/claude_inbox/remote/http.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module ClaudeInbox
+  module Remote
+    # The little of HTTP/1.1 the listener speaks: one request per
+    # connection, a body sized by Content-Length, and a response that closes
+    # the connection. Nothing here knows a route or a token.
+    module Http
+      MAX_LINE = 8 * 1024
+      MAX_HEADERS = 64
+      CHUNK = 64 * 1024
+      TOKEN = /\A[!#$%&'*+\-.^_`|~0-9A-Za-z]+\z/
+
+      REASONS = {
+        100 => "Continue", 200 => "OK", 201 => "Created", 400 => "Bad Request", 401 => "Unauthorized",
+        403 => "Forbidden", 404 => "Not Found", 405 => "Method Not Allowed", 409 => "Conflict",
+        411 => "Length Required", 413 => "Content Too Large", 415 => "Unsupported Media Type",
+        421 => "Misdirected Request", 422 => "Unprocessable Content", 500 => "Internal Server Error",
+        503 => "Service Unavailable"
+      }.freeze
+
+      HEADERS = {
+        "Connection" => "close",
+        "Cache-Control" => "no-store",
+        "X-Content-Type-Options" => "nosniff",
+        "Referrer-Policy" => "no-referrer"
+      }.freeze
+
+      JSON_TYPE = {"Content-Type" => "application/json"}.freeze
+
+      # A request refused: the status, the message and any other members for
+      # the JSON body, and the headers that status calls for. `note`, when
+      # set, is what the refusal is logged as in place of its message.
+      class Error < StandardError
+        attr_reader :status, :headers, :note
+
+        def initialize(status, message, headers: {}, note: nil, **details)
+          super(message)
+          @status = status
+          @headers = headers
+          @note = note
+          @details = details
+        end
+
+        def body = {error: Http.utf8(message), **details.transform_values { |v| v.is_a?(Integer) ? v : Http.utf8(v) }}
+
+        private
+
+        attr_reader :details
+      end
+
+      # A request head. `headers` are keyed in lower case, and a repeated
+      # header is joined with ", ", so a second Content-Length or Host can't
+      # pass for the first. The bytes read past the head stay here for the
+      # body.
+      class Request
+        attr_reader :verb, :path, :headers
+
+        def initialize(verb, target, headers, rest)
+          @verb = verb
+          @path = target.split("?", 2).first
+          @headers = headers
+          @rest = rest
+        end
+
+        # Read only once the request has earned it: a client that sent
+        # `Expect: 100-continue` holds the body back until it hears 100.
+        def read_body(io, max:, deadline:)
+          raise Error.new(400, "Transfer-Encoding isn't accepted; send Content-Length") if headers.key?("transfer-encoding")
+          length = headers["content-length"]
+          raise Error.new(411, "Content-Length is required") unless length
+          raise Error.new(400, "Content-Length isn't a number") unless length.match?(/\A\d{1,15}\z/)
+          size = length.to_i
+          raise Error.new(413, "the body is over #{max} bytes") if size > max
+          io.write("HTTP/1.1 100 Continue\r\n\r\n") if headers["expect"]&.casecmp?("100-continue") && @rest.bytesize < size
+          Http.fill(io, @rest, deadline) while @rest.bytesize < size
+          @rest.byteslice(0, size)
+        end
+      end
+
+      def self.monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      # The JSON generator warns on stderr, which is the terminal, about a
+      # binary string and raises on a bad byte, and a message can quote CLI
+      # output or request bytes.
+      def self.utf8(text) = String.new(text.to_s, encoding: Encoding::UTF_8).scrub("\uFFFD")
+
+      # `deadline` (on the monotonic clock) bounds the whole head, not each
+      # read: a per-read timeout lets a byte every few seconds hold the
+      # connection for ever.
+      def self.read_head(io, deadline:)
+        rest = +"".b
+        line = read_line(io, rest, deadline)
+        request = line.match(%r{\A(\S+) (/\S*) HTTP/1\.[01]\z})
+        raise Error.new(400, "not an HTTP/1.x request line") unless request && request[1].match?(TOKEN)
+        headers = {}
+        count = 0
+        loop do
+          line = read_line(io, rest, deadline)
+          return Request.new(request[1], request[2], headers, rest) if line.empty?
+          raise Error.new(400, "more than #{MAX_HEADERS} headers") if (count += 1) > MAX_HEADERS
+          name, value = line.split(":", 2)
+          raise Error.new(400, "malformed header") unless value && name.match?(TOKEN)
+          key = name.downcase
+          value = value.strip
+          headers[key] = headers.key?(key) ? "#{headers[key]}, #{value}" : value
+        end
+      end
+
+      def self.write(io, status, headers = {}, body = "")
+        body = body.b
+        head = ["HTTP/1.1 #{status} #{REASONS.fetch(status)}"]
+        HEADERS.merge(headers, "Content-Length" => body.bytesize.to_s).each { |name, value| head << "#{name}: #{value}" }
+        io.write((head.join("\r\n") + "\r\n\r\n").b + body)
+      end
+
+      def self.read_line(io, rest, deadline)
+        loop do
+          i = rest.index("\n")
+          raise Error.new(400, "a line of the request head is over #{MAX_LINE} bytes") if (i || rest.bytesize) > MAX_LINE
+          return rest.slice!(0..i).chomp if i
+          fill(io, rest, deadline)
+        end
+      end
+
+      def self.fill(io, rest, deadline)
+        loop do
+          case (chunk = io.read_nonblock(CHUNK, exception: false))
+          when nil then raise Error.new(400, "the connection closed mid-request")
+          when :wait_readable
+            left = deadline - monotonic
+            raise Error.new(400, "the request took too long") unless left > 0 && IO.select([io], nil, nil, left)
+          else return rest << chunk
+          end
+        end
+      end
+      private_class_method :read_line
+    end
+  end
+end

data/lib/claude_inbox/remote/icon.svg

@@ -0,0 +1,8 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512">
+  <rect width="512" height="512" fill="#0a7385"/>
+  <g fill="none" stroke="#fff" stroke-width="28" stroke-linejoin="round" stroke-linecap="round">
+    <path d="M136 150h240l44 132v92a28 28 0 0 1-28 28H120a28 28 0 0 1-28-28v-92z"/>
+    <path d="M92 282h92l26 46h92l26-46h92"/>
+    <path d="M256 170v88M220 222l36 36 36-36"/>
+  </g>
+</svg>