codex-notify 1.0.0

data/lib/codex_notify/slack_outbox.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'pathname'
+require 'securerandom'
+require 'time'
+require_relative 'secret_protection'
+
+module CodexNotify
+  class SlackOutbox
+    VERSION = 1
+    MAX_JOBS = 10_000
+    MAX_BYTES = 64 * 1024 * 1024
+
+    class Error < StandardError; end
+    class CapacityError < Error; end
+
+    def initialize(path, clock: -> { Time.now.utc })
+      @path = Pathname(path)
+      @clock = clock
+    end
+
+    attr_reader :path
+
+    def enqueue(channel:, ordering_key:, generation:, action:, chunks:, recovery_chunks: [])
+      with_state_lock do
+        enforce_capacity!
+        sequence = allocate_sequence
+        job = {
+          'version' => VERSION,
+          'id' => SecureRandom.uuid,
+          'sequence' => sequence,
+          'channel' => channel.to_s,
+          'ordering_key' => ordering_key.to_s,
+          'generation' => generation.to_i,
+          'action' => action.to_s,
+          'message_chunks' => redact_chunks(chunks),
+          'recovery_root_chunks' => redact_chunks(recovery_chunks),
+          'phase' => 'pending',
+          'next_chunk' => 0,
+          'resolved_thread_ts' => nil,
+          'attempt_count' => 0,
+          'ambiguous_attempt_count' => 0,
+          'next_attempt_at' => nil,
+          'last_error' => nil,
+          'created_at' => now.iso8601,
+          'updated_at' => now.iso8601
+        }
+        write_job(job)
+        job['id']
+      end
+    end
+
+    def pending_root?(ordering_key, generation:)
+      jobs(:pending).any? do |job|
+        job['ordering_key'] == ordering_key.to_s && job['generation'] == generation.to_i &&
+          %w[ensure_thread root_or_reply].include?(job['action'])
+      end
+    end
+
+    def jobs(status = :pending)
+      directory(status).glob('*.json').map { |file| read_job(file) }.sort_by { |job| job['sequence'] }
+    end
+
+    def update(job)
+      job['updated_at'] = now.iso8601
+      with_state_lock { write_job(job) }
+    end
+
+    def complete(job)
+      with_state_lock { job_path(job, :pending).delete if job_path(job, :pending).exist? }
+    end
+
+    def move(job, status)
+      with_state_lock do
+        source = job_path(job, :pending)
+        target = job_path(job, status)
+        target.dirname.mkpath
+        File.chmod(0o700, target.dirname)
+        File.rename(source, target) if source.exist?
+      end
+    end
+
+    def try_drain_lock
+      prepare_directories
+      File.open(@path.join('locks/drain.lock'), File::RDWR | File::CREAT, 0o600) do |file|
+        return false unless file.flock(File::LOCK_EX | File::LOCK_NB)
+
+        yield
+        true
+      ensure
+        file.flock(File::LOCK_UN) rescue nil
+      end
+    end
+
+    def status_rows
+      %i[pending needs_review failed].flat_map do |status|
+        jobs(status).map do |job|
+          {
+            status: status.to_s.tr('_', '-'), id: job['id'], sequence: job['sequence'],
+            created_at: job['created_at'], error: job.dig('last_error', 'code')
+          }
+        end
+      end
+    end
+
+    def retry(id)
+      with_state_lock do
+        source = %i[needs_review failed].map { |status| directory(status).join("#{id}.json") }.find(&:exist?)
+        raise Error, "outbox job not found: #{id}" unless source
+
+        job = read_job(source)
+        job['next_attempt_at'] = nil
+        job['last_error'] = nil
+        job['ambiguous_attempt_count'] = 0
+        source.delete
+        write_job(job)
+      end
+    end
+
+    private
+
+    def now = @clock.call.utc
+
+    def prepare_directories
+      @path.mkpath
+      File.chmod(0o700, @path)
+      %i[pending needs_review failed].each do |status|
+        directory(status).mkpath
+        File.chmod(0o700, directory(status))
+      end
+      @path.join('locks').mkpath
+      File.chmod(0o700, @path.join('locks'))
+    end
+
+    def directory(status)
+      @path.join(status.to_s.tr('_', '-'))
+    end
+
+    def with_state_lock
+      prepare_directories
+      File.open(@path.join('locks/state.lock'), File::RDWR | File::CREAT, 0o600) do |file|
+        raise Error, 'could not lock outbox state' unless file.flock(File::LOCK_EX)
+
+        cleanup_temp_files
+        yield
+      end
+    end
+
+    def cleanup_temp_files
+      [@path, *%i[pending needs_review failed].map { |status| directory(status) }].each do |dir|
+        dir.glob('.*.tmp-*').each { |file| file.delete if file.file? }
+      end
+    end
+
+    def allocate_sequence
+      index = @path.join('index.json')
+      value = index.exist? ? JSON.parse(index.read).fetch('next_sequence', 1).to_i : 1
+      atomic_write(index, JSON.generate('next_sequence' => value + 1))
+      value
+    rescue JSON::ParserError
+      raise Error, 'outbox index is invalid'
+    end
+
+    def enforce_capacity!
+      files = %i[pending needs_review failed].flat_map { |status| directory(status).glob('*.json') }
+      bytes = files.sum { |file| file.size }
+      raise CapacityError, "outbox capacity reached (#{files.size} jobs, #{bytes} bytes)" if files.size >= MAX_JOBS || bytes >= MAX_BYTES
+    end
+
+    def redact_chunks(chunks)
+      Array(chunks).map { |chunk| SecretProtection.redact(chunk.to_s) }
+    end
+
+    def write_job(job)
+      validate_job!(job)
+      atomic_write(job_path(job, :pending), JSON.generate(job))
+    end
+
+    def read_job(file)
+      job = JSON.parse(file.read)
+      validate_job!(job)
+      job
+    rescue JSON::ParserError
+      raise Error, "outbox job is invalid: #{file.basename}"
+    end
+
+    def validate_job!(job)
+      required = %w[version id sequence channel ordering_key generation action message_chunks phase next_chunk]
+      raise Error, 'outbox job is invalid' unless job.is_a?(Hash) && job['version'] == VERSION && required.all? { |key| job.key?(key) }
+    end
+
+    def job_path(job, status)
+      directory(status).join("#{job.fetch('id')}.json")
+    end
+
+    def atomic_write(path, content)
+      path.dirname.mkpath
+      tmp = path.dirname.join(".#{path.basename}.tmp-#{Process.pid}-#{SecureRandom.hex(4)}")
+      File.open(tmp, File::WRONLY | File::CREAT | File::EXCL, 0o600) { |file| file.write(content) }
+      File.rename(tmp, path)
+    ensure
+      tmp.delete if defined?(tmp) && tmp.exist?
+    end
+  end
+end

data/lib/codex_notify/stream_processor.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module CodexNotify
+  module StreamProcessor
+    module_function
+
+    def process_codex_log_stream(stream, token:, channel:, root_message:, initial_prompt: nil, user_name: 'user', include_tools: false,
+                                 throttle_sec: 0.0, post_func:, sleep_func: Kernel.method(:sleep), publisher: nil)
+      if publisher
+        return process_durable_stream(
+          stream, root_message:, initial_prompt:, user_name:, include_tools:, publisher:
+        )
+      end
+
+      last_sent_fingerprint = nil
+      thread_ts_by_session = {}
+
+      post_message = lambda do |message, thread_ts|
+        CodexNotify::MessageFormatter.chunks(message).each do |part|
+          post_func.call(token, channel, part, thread_ts)
+          sleep_func.call(throttle_sec)
+        end
+      end
+
+      post_root = lambda do |message|
+        parts = CodexNotify::MessageFormatter.chunks(message).to_a
+        response = post_func.call(token, channel, parts.shift, nil)
+        thread_ts = response.fetch('ts').to_s
+        sleep_func.call(throttle_sec)
+        parts.each do |part|
+          post_func.call(token, channel, part, thread_ts)
+          sleep_func.call(throttle_sec)
+        end
+        thread_ts
+      end
+
+      post_root.call(root_message)
+
+      unless initial_prompt.nil? || initial_prompt.empty?
+        message = CodexNotify::MessageFormatter.message(title: user_name, body: initial_prompt, presentation: :plain)
+        thread_ts_by_session['__default__'] = post_root.call(message)
+      end
+
+      stream.each do |raw|
+        line = raw.strip
+        next if line.empty?
+
+        event = JSON.parse(line)
+        session_id = CodexNotify::LogEventParser.extract_session_id(event) || '__default__'
+        extracted_events = CodexNotify::LogEventParser.extract_events(event)
+        next if extracted_events.empty?
+
+        extracted_events.each do |kind, text, part_type|
+          next if text.empty?
+          next if part_type == 'tool' && !include_tools
+
+          fingerprint = "#{session_id}:#{part_type}:#{kind}:#{text[0, 240]}"
+          next if fingerprint == last_sent_fingerprint
+
+          last_sent_fingerprint = fingerprint
+          title = kind == 'assistant' ? 'assistant' : kind
+          thread_ts = thread_ts_by_session[session_id]
+          presentation = %w[user assistant system].include?(title) ? :plain : :block
+          message_title = kind == 'user' ? user_name : title
+          message = CodexNotify::MessageFormatter.message(title: message_title, body: text, presentation:)
+
+          if kind == 'user'
+            if thread_ts
+              post_message.call(message, thread_ts)
+            else
+              thread_ts = post_root.call(message)
+              thread_ts_by_session[session_id] = thread_ts
+            end
+            next
+          end
+
+          post_message.call(message, thread_ts)
+        end
+      rescue JSON::ParserError
+        next
+      end
+
+      0
+    end
+
+    def process_durable_stream(stream, root_message:, initial_prompt:, user_name:, include_tools:, publisher:)
+      last_sent_fingerprint = nil
+      monitor_key = publisher.key('log-monitor', Process.pid)
+      publisher.publish_standalone(key: monitor_key, message: root_message)
+      return 1 unless drain_succeeded?(publisher)
+
+      unless initial_prompt.nil? || initial_prompt.empty?
+        message = CodexNotify::MessageFormatter.message(title: user_name, body: initial_prompt, presentation: :plain)
+        publisher.publish_root_or_reply(key: publisher.key('log', '__default__'), message:)
+        return 1 unless drain_succeeded?(publisher)
+      end
+
+      stream.each do |raw|
+        line = raw.strip
+        next if line.empty?
+
+        event = JSON.parse(line)
+        session_id = CodexNotify::LogEventParser.extract_session_id(event) || '__default__'
+        extracted_events = CodexNotify::LogEventParser.extract_events(event)
+        next if extracted_events.empty?
+
+        extracted_events.each do |kind, body, part_type|
+          next if body.empty?
+          next if part_type == 'tool' && !include_tools
+
+          fingerprint = "#{session_id}:#{part_type}:#{kind}:#{body[0, 240]}"
+          next if fingerprint == last_sent_fingerprint
+
+          last_sent_fingerprint = fingerprint
+          title = kind == 'assistant' ? 'assistant' : kind
+          presentation = %w[user assistant system].include?(title) ? :plain : :block
+          message_title = kind == 'user' ? user_name : title
+          message = CodexNotify::MessageFormatter.message(title: message_title, body:, presentation:)
+          key = publisher.key('log', session_id)
+          if kind == 'user'
+            publisher.publish_root_or_reply(key:, message:)
+          else
+            publisher.publish_reply(key:, message:, recovery_root_message: message)
+          end
+          return 1 unless drain_succeeded?(publisher)
+        end
+      rescue JSON::ParserError
+        next
+      end
+
+      0
+    end
+
+    def drain_succeeded?(publisher)
+      result = publisher.drain
+      result.failed.empty? && result.needs_review.empty?
+    end
+  end
+end

data/lib/codex_notify/trusted_config_loader.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'yaml'
+require_relative 'config_diagnostics'
+require_relative 'destination_name'
+
+module CodexNotify
+  class TrustedConfigLoader
+    DEFAULT_RELATIVE_PATH = Pathname('codex-notify/config.yml')
+    TOP_LEVEL_KEYS = %w[env_policy default_destination destinations].freeze
+    DESTINATION_KEYS = %w[token channel].freeze
+    ENV_POLICIES = %w[legacy restricted].freeze
+
+    class Error < StandardError; end
+
+    ConfigFile = Data.define(:kind, :path, :values)
+
+    def initialize(environment: ENV, home: nil, stderr: $stderr)
+      @environment = environment
+      @home = home
+      @stderr = stderr
+    end
+
+    def load(explicit_path: nil)
+      files = []
+      explicit = explicit_path && Pathname(explicit_path).expand_path
+      files << load_file(explicit, kind: :config_explicit, required: true) if explicit
+
+      default = default_path
+      files << load_file(default, kind: :config, required: false) unless explicit == default
+      files.compact
+    end
+
+    def default_path
+      xdg_home = environment['XDG_CONFIG_HOME']
+      if xdg_home && !xdg_home.empty?
+        base = Pathname(xdg_home)
+        raise Error, 'XDG_CONFIG_HOME must be an absolute path' unless base.absolute?
+
+        return base.join(DEFAULT_RELATIVE_PATH)
+      end
+
+      home_path = home || environment['HOME']
+      home_path = Dir.home if !home_path || home_path.empty?
+      Pathname(home_path).expand_path.join('.config', DEFAULT_RELATIVE_PATH)
+    rescue ArgumentError, SystemCallError => e
+      raise Error, "could not resolve the home configuration directory: #{e.class}"
+    end
+
+    private
+
+    attr_reader :environment, :home
+
+    def load_file(path, kind:, required:)
+      unless path.exist?
+        raise Error, "config file does not exist: #{path}" if required
+
+        return nil
+      end
+      raise Error, "config path is not a file: #{path}" unless path.file?
+
+      ConfigDiagnostics.warn_if_file_insecure(path, label: 'config file', stderr: @stderr)
+      document = YAML.safe_load_file(
+        path.to_s,
+        permitted_classes: [],
+        permitted_symbols: [],
+        aliases: false
+      )
+      ConfigFile.new(kind:, path:, values: validate(document))
+    rescue Psych::Exception
+      raise Error, "config file is not valid safe YAML: #{path}"
+    rescue SystemCallError => e
+      raise Error, "could not read config file #{path}: #{e.class}"
+    end
+
+    def validate(document)
+      mapping = require_mapping(document, 'configuration')
+      reject_unknown_keys(mapping, TOP_LEVEL_KEYS, 'configuration')
+
+      values = {}
+      apply_policy(mapping, values)
+      apply_default_destination(mapping, values)
+      apply_destinations(mapping, values)
+      values.freeze
+    end
+
+    def apply_policy(mapping, values)
+      return unless mapping.key?('env_policy')
+
+      policy = require_string(mapping['env_policy'], 'env_policy').strip.downcase
+      unless ENV_POLICIES.include?(policy)
+        raise Error, "env_policy must be one of: #{ENV_POLICIES.join(', ')}"
+      end
+
+      values['CODEX_NOTIFY_ENV_POLICY'] = policy
+    end
+
+    def apply_default_destination(mapping, values)
+      return unless mapping.key?('default_destination')
+
+      destination = require_mapping(mapping['default_destination'], 'default_destination')
+      reject_unknown_keys(destination, DESTINATION_KEYS, 'default_destination')
+      raise Error, 'default_destination must define token or channel' if destination.empty?
+
+      assign_string(destination, 'token', values, 'SLACK_BOT_TOKEN', context: 'default_destination')
+      assign_string(destination, 'channel', values, 'SLACK_CHANNEL', context: 'default_destination')
+    end
+
+    def apply_destinations(mapping, values)
+      return unless mapping.key?('destinations')
+
+      destinations = require_mapping(mapping['destinations'], 'destinations')
+      normalized_names = {}
+      destinations.each do |raw_name, raw_destination|
+        raise Error, 'destination names must be strings' unless raw_name.is_a?(String)
+
+        name = DestinationName.normalize(raw_name)
+        raise Error, "destination name is duplicated after normalization: #{name}" if normalized_names.key?(name)
+
+        normalized_names[name] = true
+        destination = require_mapping(raw_destination, "destination #{name}")
+        reject_unknown_keys(destination, DESTINATION_KEYS, "destination #{name}")
+        raise Error, "destination #{name} must define channel" unless destination.key?('channel')
+
+        assign_string(destination, 'token', values, "SLACK_BOT_TOKEN__#{name}", context: "destination #{name}")
+        assign_string(destination, 'channel', values, "SLACK_CHANNEL__#{name}", context: "destination #{name}")
+      end
+    rescue DestinationName::Error => e
+      raise Error, e.message
+    end
+
+    def assign_string(mapping, key, values, output_key, context:)
+      return unless mapping.key?(key)
+
+      values[output_key] = require_string(mapping[key], "#{context}.#{key}")
+    end
+
+    def require_mapping(value, label)
+      raise Error, "#{label} must be a mapping" unless value.is_a?(Hash)
+      raise Error, "#{label} keys must be strings" unless value.keys.all? { |key| key.is_a?(String) }
+
+      value
+    end
+
+    def require_string(value, label)
+      raise Error, "#{label} must be a non-empty string" unless value.is_a?(String) && !value.strip.empty?
+
+      value
+    end
+
+    def reject_unknown_keys(mapping, allowed, label)
+      unknown = mapping.keys - allowed
+      return if unknown.empty?
+
+      raise Error, "#{label} contains unknown keys"
+    end
+  end
+end

data/lib/codex_notify/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module CodexNotify
+  VERSION = '1.0.0'
+end

data/lib/codex_notify.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative 'codex_notify/version'
+require_relative 'codex_notify/log_event_parser'
+require_relative 'codex_notify/message_formatter'
+require_relative 'codex_notify/session_log'
+require_relative 'codex_notify/stream_processor'
+require_relative 'codex_notify/secret_protection'
+require_relative 'codex_notify/config_diagnostics'
+require_relative 'codex_notify/config_support'
+require_relative 'codex_notify/destination_name'
+require_relative 'codex_notify/trusted_config_loader'
+require_relative 'codex_notify/config_migrator'
+require_relative 'codex_notify/config'
+require_relative 'codex_notify/cli'
+require_relative 'codex_notify/slack_client'
+require_relative 'codex_notify/slack_outbox'
+require_relative 'codex_notify/slack_delivery_worker'
+require_relative 'codex_notify/durable_slack_publisher'
+require_relative 'codex_notify/outbox_commands'
+require_relative 'codex_notify/env_source_loader'
+require_relative 'codex_notify/destination_resolver'
+require_relative 'codex_notify/hook_config'
+require_relative 'codex_notify/hook_event'
+require_relative 'codex_notify/hook_input_validator'
+require_relative 'codex_notify/hook_store'
+require_relative 'codex_notify/hook_formatter'
+require_relative 'codex_notify/hook_thread_publisher'
+require_relative 'codex_notify/hook_runner'
+require_relative 'codex_notify/hook_cli'
+
+module CodexNotify
+  def self.main(*args, **kwargs)
+    CLI.main(*args, **kwargs)
+  end
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: codex-notify
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Koichiro Ohba
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+description: Log-tail and Codex Hook commands that send compact Codex activity notifications
+  to Slack.
+email:
+- koichiro.ohba@gmail.com
+executables:
+- codex-notify
+- codex-notify-hook
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- bin/codex-notify
+- bin/codex-notify-hook
+- lib/codex_notify.rb
+- lib/codex_notify/cli.rb
+- lib/codex_notify/config.rb
+- lib/codex_notify/config_diagnostics.rb
+- lib/codex_notify/config_migrator.rb
+- lib/codex_notify/config_support.rb
+- lib/codex_notify/destination_name.rb
+- lib/codex_notify/destination_resolver.rb
+- lib/codex_notify/durable_slack_publisher.rb
+- lib/codex_notify/env_source_loader.rb
+- lib/codex_notify/hook_cli.rb
+- lib/codex_notify/hook_config.rb
+- lib/codex_notify/hook_event.rb
+- lib/codex_notify/hook_formatter.rb
+- lib/codex_notify/hook_input_validator.rb
+- lib/codex_notify/hook_runner.rb
+- lib/codex_notify/hook_store.rb
+- lib/codex_notify/hook_thread_publisher.rb
+- lib/codex_notify/log_event_parser.rb
+- lib/codex_notify/message_formatter.rb
+- lib/codex_notify/outbox_commands.rb
+- lib/codex_notify/secret_protection.rb
+- lib/codex_notify/session_log.rb
+- lib/codex_notify/slack_client.rb
+- lib/codex_notify/slack_delivery_worker.rb
+- lib/codex_notify/slack_outbox.rb
+- lib/codex_notify/stream_processor.rb
+- lib/codex_notify/trusted_config_loader.rb
+- lib/codex_notify/version.rb
+homepage: https://github.com/koichiro/codex-notify
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/koichiro/codex-notify/tree/v1.0.0
+  bug_tracker_uri: https://github.com/koichiro/codex-notify/issues
+  changelog_uri: https://github.com/koichiro/codex-notify/blob/v1.0.0/CHANGELOG.md
+  documentation_uri: https://github.com/koichiro/codex-notify#readme
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Send compact Codex activity notifications to Slack
+test_files: []