codex-notify 1.0.0

data/lib/codex_notify/message_formatter.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module CodexNotify
+  module MessageFormatter
+    SLACK_SAFE_LENGTH = 3500
+    CONTINUATION_LABEL = '(cont.)'
+    PRESENTATIONS = %i[plain block].freeze
+    Message = Data.define(:title, :body, :presentation)
+
+    module_function
+
+    def message(title:, body:, presentation:)
+      unless PRESENTATIONS.include?(presentation)
+        raise ArgumentError, "unsupported message presentation: #{presentation.inspect}"
+      end
+
+      Message.new(
+        title: title.to_s.dup.freeze,
+        body: body.to_s.dup.freeze,
+        presentation:
+      )
+    end
+
+    def chunks(message, max_length: SLACK_SAFE_LENGTH)
+      return enum_for(__method__, message, max_length:) unless block_given?
+
+      validate_max_length(max_length, message.presentation)
+      body = message.body.gsub("\r\n", "\n")
+      index = 0
+      chunk_index = 0
+
+      loop do
+        title = fit_title(
+          message.title,
+          message.presentation,
+          max_length,
+          body.empty?,
+          continuation: chunk_index.positive?
+        )
+        capacity = max_length - render(title, '', message.presentation).length
+        part = body[index, capacity] || ''
+        yield render(title, part, message.presentation)
+
+        index += part.length
+        break if index >= body.length
+
+        chunk_index += 1
+      end
+    end
+
+    def fmt_block(title, body)
+      render(title.to_s, body.to_s, :block)
+    end
+
+    def build_root_message(title, cwd, user_name: 'user', session_id: nil)
+      body = root_body(cwd, user_name:, session_id:)
+      message(title:, body:, presentation: :block)
+    end
+
+    def build_root_text(title, cwd, user_name: 'user', session_id: nil)
+      fmt_block(title, root_body(cwd, user_name:, session_id:))
+    end
+
+    def fmt_plain(title, body)
+      render(title.to_s, body.to_s, :plain)
+    end
+
+    def root_body(cwd, user_name:, session_id:)
+      [
+        'Codex log monitoring started.',
+        "CWD: #{cwd}",
+        "User: #{user_name}",
+        "Session ID: #{session_id || 'unknown'}"
+      ].join("\n")
+    end
+    private_class_method :root_body
+
+    def render(title, body, presentation)
+      case presentation
+      when :plain then "*#{title}*\n#{body}"
+      when :block then "*#{title}*\n```#{body}```"
+      else raise ArgumentError, "unsupported message presentation: #{presentation.inspect}"
+      end
+    end
+    private_class_method :render
+
+    def validate_max_length(max_length, presentation)
+      minimum_length = render('', '', presentation).length + 1
+      return if max_length >= minimum_length
+
+      raise ArgumentError, "max_length must be at least #{minimum_length} for #{presentation} messages"
+    end
+    private_class_method :validate_max_length
+
+    def fit_title(title, presentation, max_length, empty_body, continuation:)
+      body_reserve = empty_body ? 0 : 1
+      max_title_length = max_length - render('', '', presentation).length - body_reserve
+      return truncate(title, max_title_length) unless continuation
+      return truncate(CONTINUATION_LABEL, max_title_length) if max_title_length <= CONTINUATION_LABEL.length
+
+      base = truncate(title, max_title_length - CONTINUATION_LABEL.length - 1)
+      base.empty? ? CONTINUATION_LABEL : "#{base} #{CONTINUATION_LABEL}"
+    end
+    private_class_method :fit_title
+
+    def truncate(text, max_length)
+      return '' if max_length <= 0
+      return text if text.length <= max_length
+      return '…' if max_length == 1
+
+      "#{text[0, max_length - 1]}…"
+    end
+    private_class_method :truncate
+  end
+end

data/lib/codex_notify/outbox_commands.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'pathname'
+require_relative 'hook_store'
+require_relative 'slack_client'
+require_relative 'slack_delivery_worker'
+require_relative 'slack_outbox'
+
+module CodexNotify
+  module OutboxCommands
+    module_function
+
+    def run(action:, id:, outbox_dir:, token:, channel:, state_file:, stdout:, stderr:)
+      outbox = SlackOutbox.new(outbox_dir)
+      case action
+      when :status
+        outbox.status_rows.each { |row| stdout.puts(JSON.generate(row)) }
+        0
+      when :retry
+        outbox.retry(id)
+        0
+      when :drain
+        unless token && channel
+          stderr.puts('ERROR: draining the outbox requires Slack token and channel configuration')
+          return 2
+        end
+        store = HookStore.new(state_file)
+        result = SlackDeliveryWorker.new(
+          outbox:,
+          client: SlackClient.new(token:, channel:),
+          store:
+        ).drain(channel:)
+        failed = result.failed.any? || result.needs_review.any?
+        stderr.puts('ERROR: Slack delivery requires outbox review; run --outbox-status') if failed
+        failed ? 1 : 0
+      end
+    rescue SlackOutbox::Error => e
+      stderr.puts("ERROR: #{e.message}")
+      1
+    end
+  end
+end

data/lib/codex_notify/secret_protection.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module CodexNotify
+  module SecretProtection
+    REDACTED = '[REDACTED]'
+    SENSITIVE_NAME = /(?:authorization|proxy[-_]?authorization|token|secret|password|passwd|api[-_]?key)/i
+    KNOWN_SECRET_PATTERNS = [
+      /\bxox[baprs]-[A-Za-z0-9][A-Za-z0-9-]*\b/,
+      /\bxapp-[A-Za-z0-9][A-Za-z0-9-]*\b/,
+      /\bgh[pousr]_[A-Za-z0-9]{20,}\b/,
+      /\bsk-[A-Za-z0-9_-]{16,}\b/,
+      /\bAKIA[0-9A-Z]{16}\b/
+    ].freeze
+
+    module_function
+
+    def redact(value)
+      text = value.to_s.dup
+
+      text.gsub!(/(\b(?:[A-Za-z_][A-Za-z0-9_.-]*)?(?:proxy[-_]?authorization|authorization)[A-Za-z0-9_.-]*\s*[=:]\s*)(?:(?:Bearer|Basic)\s+)?[^\s'",;}]+/i) do
+        "#{Regexp.last_match(1)}#{REDACTED}"
+      end
+      text.gsub!(/(--(?:token|password|passwd|secret|api[-_]?key)(?:=|\s+))(?:"[^"]*"|'[^']*'|[^\s]+)/i) do
+        "#{Regexp.last_match(1)}#{REDACTED}"
+      end
+      text.gsub!(/("[^"]*#{SENSITIVE_NAME.source}[^"]*"\s*:\s*)(?:"(?:\\.|[^"])*"|'(?:\\.|[^'])*'|[^\s,}\]]+)/i) do
+        "#{Regexp.last_match(1)}#{REDACTED}"
+      end
+      text.gsub!(/(\b(?:[A-Za-z_][A-Za-z0-9_.-]*)?#{SENSITIVE_NAME.source}[A-Za-z0-9_.-]*\s*[=:]\s*)(?:"[^"]*"|'[^']*'|[^\s,;}]+)/i) do
+        "#{Regexp.last_match(1)}#{REDACTED}"
+      end
+      KNOWN_SECRET_PATTERNS.each { |pattern| text.gsub!(pattern, REDACTED) }
+
+      text
+    end
+  end
+end

data/lib/codex_notify/session_log.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'pathname'
+
+module CodexNotify
+  module SessionLog
+    module_function
+
+    def iter_follow_lines(path, poll_sec: 1.0, once: false, start_at_end: true, sleep_func: Kernel.method(:sleep))
+      return enum_for(__method__, path, poll_sec:, once:, start_at_end:, sleep_func:) unless block_given?
+
+      Pathname(path).open('r:utf-8') do |handle|
+        handle.seek(0, IO::SEEK_END) if start_at_end
+        loop do
+          line = handle.gets
+          if line
+            yield line
+            next
+          end
+          break if once
+
+          sleep_func.call(poll_sec)
+        end
+      end
+    end
+
+    def find_latest_session_file(sessions_dir)
+      root = Pathname(sessions_dir)
+      return nil unless root.exist?
+
+      files = root.glob('**/*.jsonl').select(&:file?)
+      return nil if files.empty?
+
+      files.max_by { |path| path.stat.mtime.to_f }
+    end
+
+    def session_id_from_log(path)
+      pathname = Pathname(path)
+      return nil unless pathname.exist?
+
+      pathname.open('r:utf-8') do |handle|
+        handle.each_line do |raw|
+          line = raw.strip
+          next if line.empty?
+
+          event = JSON.parse(line)
+          session_id = CodexNotify::LogEventParser.extract_session_id(event)
+          return session_id if session_id
+        rescue JSON::ParserError
+          next
+        end
+      end
+
+      nil
+    end
+
+    def session_id_from_path(path)
+      pathname = Pathname(path)
+      pathname.basename('.jsonl').to_s
+    end
+  end
+end

data/lib/codex_notify/slack_client.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+require 'uri'
+require_relative 'secret_protection'
+
+module CodexNotify
+  class SlackClient
+    class Error < StandardError
+      attr_reader :response, :error_code, :http_status, :retry_after
+
+      def initialize(message, response: nil, error_code: nil, http_status: nil, retry_after: nil,
+                     retryable: false, ambiguous: false, stale_thread: false)
+        super(message)
+        @response = response
+        @error_code = error_code
+        @http_status = http_status
+        @retry_after = retry_after
+        @retryable = retryable
+        @ambiguous = ambiguous
+        @stale_thread = stale_thread
+      end
+
+      def retryable? = @retryable
+      def ambiguous? = @ambiguous
+      def stale_thread? = @stale_thread
+    end
+
+    SLACK_API = 'https://slack.com/api/chat.postMessage'
+    OPEN_TIMEOUT = 5
+    WRITE_TIMEOUT = 10
+    READ_TIMEOUT = 20
+    RETRYABLE_CODES = %w[ratelimited rate_limited internal_error fatal_error service_unavailable request_timeout].freeze
+    AMBIGUOUS_CODES = %w[internal_error fatal_error service_unavailable request_timeout].freeze
+    STALE_THREAD_CODES = %w[thread_not_found message_not_found invalid_ts].freeze
+
+    def initialize(token:, channel:)
+      @token = token
+      @channel = channel
+    end
+
+    def post(text, thread_ts: nil)
+      payload = { channel: @channel, text: SecretProtection.redact(text) }
+      payload[:thread_ts] = thread_ts.to_s if thread_ts
+
+      uri = URI(SLACK_API)
+      request = Net::HTTP::Post.new(uri)
+      request['Content-Type'] = 'application/json; charset=utf-8'
+      request['Authorization'] = "Bearer #{@token}"
+      request.body = JSON.generate(payload)
+
+      request_started = false
+      response = Net::HTTP.start(
+        uri.hostname,
+        uri.port,
+        use_ssl: true,
+        open_timeout: OPEN_TIMEOUT,
+        write_timeout: WRITE_TIMEOUT,
+        read_timeout: READ_TIMEOUT
+      ) do |http|
+        request_started = true
+        http.request(request)
+      end
+
+      status = response.respond_to?(:code) ? response.code.to_i : 200
+      retry_after = parse_retry_after(response_header(response, 'Retry-After'))
+      if status == 429
+        raise build_error('Slack rate limited request', http_status: status, retry_after:, retryable: true)
+      end
+      if status >= 500
+        raise build_error('Slack server error', http_status: status, retryable: true, ambiguous: true)
+      end
+
+      parsed = JSON.parse(response.body.to_s)
+      unless parsed['ok']
+        code = parsed['error'].to_s
+        raise build_error(
+          "Slack API error: #{code.empty? ? 'unknown' : code}",
+          response: parsed,
+          error_code: code,
+          retry_after:,
+          retryable: RETRYABLE_CODES.include?(code),
+          ambiguous: AMBIGUOUS_CODES.include?(code),
+          stale_thread: STALE_THREAD_CODES.include?(code)
+        )
+      end
+
+      parsed
+    rescue Net::OpenTimeout, SocketError => e
+      raise build_error("Slack connection failed: #{e.class}", retryable: true)
+    rescue OpenSSL::SSL::SSLError, SystemCallError => e
+      raise build_error("Slack connection failed: #{e.class}", retryable: true, ambiguous: request_started)
+    rescue Net::WriteTimeout, Net::ReadTimeout, EOFError, Errno::ECONNRESET, Errno::EPIPE => e
+      raise build_error("Slack request outcome is unknown: #{e.class}", retryable: true, ambiguous: request_started)
+    rescue JSON::ParserError
+      raise build_error('Slack returned an invalid JSON response', retryable: true, ambiguous: true)
+    end
+
+    private
+
+    def build_error(message, **attributes)
+      Error.new(message, **attributes)
+    end
+
+    def parse_retry_after(value)
+      seconds = Integer(value, exception: false)
+      seconds if seconds && seconds >= 0
+    end
+
+    def response_header(response, name)
+      response[name] if response.respond_to?(:[])
+    rescue NameError, IndexError
+      nil
+    end
+  end
+end

data/lib/codex_notify/slack_delivery_worker.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+require 'time'
+require_relative 'slack_client'
+
+module CodexNotify
+  class SlackDeliveryWorker
+    STALE_THREAD_CODES = %w[thread_not_found message_not_found invalid_ts].freeze
+    DRAIN_BUDGET = 10.0
+    MAX_IMMEDIATE_ATTEMPTS = 3
+    MAX_AMBIGUOUS_ATTEMPTS = 3
+    BACKOFF_CAP = 8.0
+
+    Result = Data.define(:delivered, :deferred, :failed, :needs_review)
+
+    def initialize(outbox:, client:, store:, clock: -> { Time.now.utc }, monotonic_clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) },
+                   sleeper: Kernel.method(:sleep), random: Random.new, inter_message_delay: 0.0)
+      @outbox = outbox
+      @client = client
+      @store = store
+      @clock = clock
+      @monotonic_clock = monotonic_clock
+      @sleeper = sleeper
+      @random = random
+      @inter_message_delay = inter_message_delay
+    end
+
+    def drain(channel:, budget: DRAIN_BUDGET)
+      counts = { delivered: [], deferred: [], failed: [], needs_review: [] }
+      locked = @outbox.try_drain_lock do
+        deadline = monotonic_now + budget
+        drain_jobs(channel.to_s, deadline, counts)
+      end
+      return Result.new(**counts) if locked
+
+      counts[:deferred] = @outbox.jobs.select { |job| job['channel'] == channel.to_s }.map { |job| job['id'] }
+      Result.new(**counts)
+    end
+
+    private
+
+    def drain_jobs(channel, deadline, counts)
+      immediate_attempts = Hash.new(0)
+      loop do
+        job = next_eligible_job(channel)
+        break unless job
+        break if monotonic_now >= deadline
+
+        outcome = deliver_with_lock(job)
+        if outcome == :delivered
+          @outbox.complete(job)
+          counts[:delivered] << job['id']
+          next
+        end
+      rescue SlackClient::Error => e
+        immediate_attempts[job['id']] += 1
+        disposition = handle_delivery_error(job, e, immediate_attempts[job['id']], deadline)
+        next if disposition == :retry_now
+
+        counts[disposition] << job['id'] unless counts[disposition].include?(job['id'])
+        break if disposition == :deferred && blocking_head?(job)
+      end
+    end
+
+    def next_eligible_job(channel)
+      blocked = (@outbox.jobs(:failed) + @outbox.jobs(:needs_review)).map { |job| job['ordering_key'] }.uniq
+      seen = {}
+      @outbox.jobs.find do |job|
+        key = job['ordering_key']
+        next false if seen[key]
+
+        seen[key] = true
+        next false if blocked.include?(key) || job['channel'] != channel
+
+        due?(job)
+      end
+    end
+
+    def blocking_head?(job)
+      @outbox.jobs.none? do |candidate|
+        candidate['channel'] == job['channel'] && candidate['ordering_key'] != job['ordering_key'] && due?(candidate)
+      end
+    end
+
+    def due?(job)
+      value = job['next_attempt_at']
+      value.nil? || Time.iso8601(value) <= now
+    rescue ArgumentError
+      true
+    end
+
+    def deliver_with_lock(job)
+      @store.with_session_lock(job['ordering_key']) do
+        current = @outbox.jobs.find { |candidate| candidate['id'] == job['id'] }
+        return :delivered unless current
+
+        job.replace(current)
+        if @store.generation_for(job['ordering_key']) != job['generation'].to_i
+          return :delivered
+        end
+        if job['resolved_thread_ts'] && job['action'] != 'standalone'
+          @store.save_thread_ts(job['ordering_key'], job['resolved_thread_ts'])
+        end
+
+        deliver(job)
+      end
+    end
+
+    def deliver(job)
+      case job['phase']
+      when 'pending'
+        start_job(job)
+      when 'posting_root', 'posting_recovery_root'
+        post_root(job)
+      when 'posting_root_remainder', 'posting_recovery_remainder'
+        post_root_remainder(job)
+      when 'posting_message'
+        post_message(job)
+      else
+        raise SlackOutbox::Error, "unknown outbox phase: #{job['phase']}"
+      end
+    rescue SlackClient::Error => e
+      stale = e.stale_thread? || STALE_THREAD_CODES.include?(e.error_code)
+      already_recovering = job['phase'].to_s.include?('recovery')
+      root_not_created = job['phase'] == 'posting_root'
+      raise unless stale && job['action'] != 'standalone' && !already_recovering && !root_not_created
+
+      @store.clear_thread(job['ordering_key'])
+      job['phase'] = 'posting_recovery_root'
+      job['next_chunk'] = 0
+      job['resolved_thread_ts'] = nil
+      @outbox.update(job)
+      deliver(job)
+    end
+
+    def start_job(job)
+      case job['action']
+      when 'standalone'
+        transition(job, 'posting_root')
+      when 'ensure_thread', 'root_or_reply'
+        if (thread_ts = @store.thread_ts_for(job['ordering_key']))
+          return :delivered if job['action'] == 'ensure_thread'
+
+          job['resolved_thread_ts'] = thread_ts
+          transition(job, 'posting_message')
+        else
+          transition(job, 'posting_root')
+        end
+      when 'reply'
+        thread_ts = @store.thread_ts_for(job['ordering_key'])
+        return :delivered unless thread_ts
+
+        job['resolved_thread_ts'] = thread_ts
+        transition(job, 'posting_message')
+      else
+        raise SlackOutbox::Error, "unknown outbox action: #{job['action']}"
+      end
+    end
+
+    def post_root(job)
+      chunks = root_chunks(job)
+      return finish_root(job) if chunks.empty?
+
+      response = post(chunks.fetch(0))
+      job['resolved_thread_ts'] = response.fetch('ts').to_s
+      job['next_chunk'] = 1
+      job['phase'] = job['phase'] == 'posting_recovery_root' ? 'posting_recovery_remainder' : 'posting_root_remainder'
+      @outbox.update(job)
+      @store.save_thread_ts(job['ordering_key'], job['resolved_thread_ts']) unless job['action'] == 'standalone'
+      deliver(job)
+    end
+
+    def post_root_remainder(job)
+      chunks = root_chunks(job)
+      while job['next_chunk'] < chunks.length
+        post(chunks.fetch(job['next_chunk']), thread_ts: job['resolved_thread_ts'])
+        job['next_chunk'] += 1
+        @outbox.update(job)
+      end
+      finish_root(job)
+    end
+
+    def finish_root(job)
+      if job['phase'].to_s.include?('recovery') && job['message_chunks'] != job['recovery_root_chunks']
+        job['next_chunk'] = 0
+        transition(job, 'posting_message')
+      else
+        :delivered
+      end
+    end
+
+    def post_message(job)
+      chunks = job['message_chunks']
+      while job['next_chunk'] < chunks.length
+        post(chunks.fetch(job['next_chunk']), thread_ts: job['resolved_thread_ts'])
+        job['next_chunk'] += 1
+        @outbox.update(job)
+      end
+      :delivered
+    end
+
+    def root_chunks(job)
+      job['phase'].to_s.include?('recovery') ? job['recovery_root_chunks'] : job['message_chunks']
+    end
+
+    def transition(job, phase)
+      job['phase'] = phase
+      job['next_chunk'] = 0
+      @outbox.update(job)
+      deliver(job)
+    end
+
+    def post(text, thread_ts: nil)
+      response = @client.post(text, thread_ts:)
+      @sleeper.call(@inter_message_delay) if @inter_message_delay.positive?
+      response
+    end
+
+    def handle_delivery_error(job, error, immediate_attempt, deadline)
+      job['attempt_count'] += 1
+      job['last_error'] = {
+        'code' => error.error_code,
+        'http_status' => error.http_status,
+        'ambiguous' => error.ambiguous?
+      }.compact
+
+      unless error.retryable?
+        @outbox.update(job)
+        @outbox.move(job, :failed)
+        return :failed
+      end
+
+      if error.ambiguous?
+        job['ambiguous_attempt_count'] += 1
+        @outbox.update(job)
+        if job['ambiguous_attempt_count'] >= MAX_AMBIGUOUS_ATTEMPTS
+          @outbox.move(job, :needs_review)
+          return :needs_review
+        end
+        schedule(job, backoff(job['attempt_count']))
+        return :deferred
+      end
+
+      delay = error.retry_after || backoff(job['attempt_count'])
+      if immediate_attempt < MAX_IMMEDIATE_ATTEMPTS && monotonic_now + delay < deadline
+        @sleeper.call(delay)
+        job['next_attempt_at'] = nil
+        @outbox.update(job)
+        return :retry_now
+      end
+
+      schedule(job, delay)
+      :deferred
+    end
+
+    def schedule(job, delay)
+      job['next_attempt_at'] = (now + delay).iso8601
+      @outbox.update(job)
+    end
+
+    def backoff(attempt)
+      cap = [0.5 * (2**([attempt - 1, 0].max)), BACKOFF_CAP].min
+      @random.rand * cap
+    end
+
+    def now = @clock.call.utc
+    def monotonic_now = @monotonic_clock.call
+  end
+end