codex-notify 1.0.0

data/lib/codex_notify/hook_runner.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require_relative 'hook_config'
+require_relative 'hook_store'
+require_relative 'hook_formatter'
+require_relative 'hook_thread_publisher'
+require_relative 'slack_client'
+require_relative 'slack_outbox'
+
+module CodexNotify
+  class HookRunner
+    RESET_THREAD_PROMPT = '---'
+    SESSION_RESET_SOURCES = %w[startup clear].freeze
+    INTERNAL_AMBIENT_SUGGESTIONS_PROMPTS = [
+      [
+        '# Overview',
+        'Generate 0 to 3 hyperpersonalized suggestions for what this user can do with Codex in this local project',
+        "Suggest actionable tasks that they would actually act on/click"
+      ].freeze,
+      [
+        'You are an expert at upholding safety and compliance standards for Codex ambient suggestions.',
+        'ambient suggestion candidates',
+        '## 1. Policies to always exclude'
+      ].freeze
+    ].freeze
+    INTERNAL_AMBIENT_SUGGESTIONS_RESPONSES = [
+      [
+        'exclude',
+        'suggestion_id',
+        'Only output the JSON object'
+      ].freeze,
+      [
+        'suggestions to exclude',
+        'reason',
+        'applicable policy'
+      ].freeze
+    ].freeze
+
+    def initialize(token:, channel:, user_name:, title:, state_file:, mode: HookConfig::DEFAULT_MODE, stdout: $stdout,
+                   client: nil, store: nil, outbox: nil, outbox_dir: nil)
+      @store = store || HookStore.new(state_file)
+      client ||= SlackClient.new(token:, channel:)
+      outbox ||= SlackOutbox.new(outbox_dir || "#{state_file}.outbox")
+      @publisher = HookThreadPublisher.new(client:, store: @store, outbox:, channel:)
+      @user_name = user_name
+      @title = title
+      @mode = mode
+      @stdout = stdout
+    end
+
+    def run(event:)
+      @store.with_session_lock(event.session_id) do
+        case event.name
+        when 'SessionStart'
+          handle_session_start(event)
+        when 'UserPromptSubmit'
+          handle_user_prompt_submit(event)
+        when 'PreToolUse'
+          handle_pre_tool_use(event)
+        when 'PostToolUse'
+          handle_post_tool_use(event)
+        when 'PermissionRequest'
+          handle_permission_request(event)
+        when 'Stop'
+          handle_stop(event)
+        end
+      end
+
+      result = @publisher.drain
+      result&.failed&.any? || result&.needs_review&.any? ? 1 : 0
+    end
+
+    private
+
+    def session_root_message(event)
+      title = @title || "Codex session: #{File.basename(event.cwd)}"
+      HookFormatter.session_root_message(event, title:, user_name: @user_name)
+    end
+
+    def handle_session_start(event)
+      if reset_thread_on_session_start?(event)
+        session_id = event.session_id
+        @publisher.reset_thread(session_id:)
+        @store.clear_suppressed_session(session_id)
+      end
+      @publisher.ensure_thread(session_id: event.session_id, root_message: session_root_message(event)) if debug?
+    end
+
+    def handle_user_prompt_submit(event)
+      prompt = event.prompt
+      session_id = event.session_id
+      if normal? && internal_ambient_suggestions_prompt?(prompt)
+        @store.suppress_session(session_id, 'internal_ambient_suggestions')
+        return
+      end
+
+      @store.clear_suppressed_session(session_id)
+
+      if reset_thread_prompt?(prompt)
+        @publisher.reset_thread(session_id:)
+        return
+      end
+
+      message = HookFormatter.prompt_message(event, user_name: @user_name)
+      @publisher.publish_root_or_reply(session_id:, message:)
+    end
+
+    def handle_pre_tool_use(event)
+      return unless debug?
+
+      @publisher.publish_reply(
+        session_id: event.session_id,
+        message: HookFormatter.pre_tool_message(event),
+        recovery_root_message: session_root_message(event)
+      )
+    end
+
+    def handle_post_tool_use(event)
+      return unless debug?
+
+      @publisher.publish_reply(
+        session_id: event.session_id,
+        message: HookFormatter.post_tool_message(event),
+        recovery_root_message: session_root_message(event)
+      )
+    end
+
+    def handle_permission_request(event)
+      message = HookFormatter.permission_request_message(event)
+      @publisher.publish_root_or_reply(session_id: event.session_id, message:)
+    end
+
+    def handle_stop(event)
+      session_id = event.session_id
+      return if normal? && @store.suppressed_session?(session_id)
+
+      message = event.assistant_message
+      return if normal? && internal_ambient_suggestions_response?(message)
+
+      unless message.nil? || message.to_s.empty?
+        @publisher.publish_reply(
+          session_id:,
+          message: HookFormatter.assistant_message(event),
+          recovery_root_message: session_root_message(event)
+        )
+      end
+    end
+
+    def reset_thread_prompt?(prompt)
+      prompt.to_s.strip == RESET_THREAD_PROMPT
+    end
+
+    def reset_thread_on_session_start?(event)
+      SESSION_RESET_SOURCES.include?(event.source.to_s)
+    end
+
+    def internal_ambient_suggestions_prompt?(prompt)
+      text = prompt.to_s
+      INTERNAL_AMBIENT_SUGGESTIONS_PROMPTS.any? do |markers|
+        markers.all? { |marker| text.include?(marker) }
+      end
+    end
+
+    def internal_ambient_suggestions_response?(message)
+      text = message.to_s
+      return false if text.empty?
+
+      INTERNAL_AMBIENT_SUGGESTIONS_RESPONSES.any? do |markers|
+        markers.all? { |marker| text.include?(marker) }
+      end
+    end
+
+    def normal?
+      @mode == 'normal'
+    end
+
+    def debug?
+      @mode == 'debug'
+    end
+  end
+end

data/lib/codex_notify/hook_store.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'json'
+require 'pathname'
+require 'time'
+require 'tmpdir'
+
+module CodexNotify
+  class HookStore
+    def initialize(path)
+      @path = Pathname(path)
+    end
+
+    def thread_ts_for(session_id)
+      state.dig('threads', session_id.to_s)
+    end
+
+    def save_thread_ts(session_id, thread_ts)
+      update_state do |data|
+        data['threads'][session_id.to_s] = thread_ts.to_s
+      end
+    end
+
+    def clear_thread(session_id)
+      update_state do |data|
+        data['threads'].delete(session_id.to_s)
+      end
+    end
+
+    def suppress_session(session_id, reason)
+      update_state do |data|
+        key = session_id.to_s
+        data['threads'].delete(key)
+        data['generations'][key] = data['generations'].fetch(key, 0).to_i + 1
+        data['suppressed_sessions'][key] = {
+          'reason' => reason.to_s,
+          'suppressed_at' => Time.now.utc.iso8601
+        }
+      end
+    end
+
+    def suppressed_session?(session_id)
+      state.fetch('suppressed_sessions', {}).key?(session_id.to_s)
+    end
+
+    def clear_suppressed_session(session_id)
+      update_state do |data|
+        data['suppressed_sessions'].delete(session_id.to_s)
+      end
+    end
+
+    def generation_for(session_id)
+      state.fetch('generations', {}).fetch(session_id.to_s, 0).to_i
+    end
+
+    def advance_generation(session_id)
+      update_state do |data|
+        key = session_id.to_s
+        data['threads'].delete(key)
+        data['generations'][key] = data['generations'].fetch(key, 0).to_i + 1
+      end
+    end
+
+    # Keep each hook event for a session atomic, including any Slack calls made
+    # between reading and updating the state file. Callers must acquire this
+    # session lock before an operation that takes the state lock.
+    def with_session_lock(session_id)
+      digest = Digest::SHA256.hexdigest(session_id.to_s)
+      with_file_lock(session_lock_dir.join("#{digest}.lock")) { yield }
+    end
+
+    private
+
+    def state
+      return default_state unless @path.exist?
+
+      normalize_state(JSON.parse(@path.read))
+    rescue JSON::ParserError
+      default_state
+    end
+
+    def default_state
+      { 'threads' => {}, 'suppressed_sessions' => {}, 'generations' => {} }
+    end
+
+    def normalize_state(data)
+      data = {} unless data.is_a?(Hash)
+      defaults = default_state
+      defaults.merge(data) do |_key, default_value, value|
+        value.is_a?(Hash) ? value : default_value
+      end
+    end
+
+    def update_state
+      with_file_lock(state_lock_path) do
+        data = state
+        yield(data)
+        write_state(data)
+      end
+    end
+
+    def state_lock_path
+      @path.dirname.join("#{@path.basename}.lock")
+    end
+
+    def session_lock_dir
+      @path.dirname.join("#{@path.basename}.locks")
+    end
+
+    def with_file_lock(path)
+      path.dirname.mkpath
+      File.open(path, File::RDWR | File::CREAT, 0o600) do |file|
+        locked = false
+        raise IOError, "could not lock #{path}" unless file.flock(File::LOCK_EX)
+
+        locked = true
+        yield
+      ensure
+        file.flock(File::LOCK_UN) if locked
+      end
+    end
+
+    def write_state(data)
+      @path.dirname.mkpath
+      tmp = @path.dirname.join(".#{@path.basename}.tmp-#{Process.pid}")
+      tmp.write(JSON.pretty_generate(data))
+      File.rename(tmp, @path)
+    ensure
+      tmp.delete if defined?(tmp) && tmp.exist?
+    end
+  end
+end

data/lib/codex_notify/hook_thread_publisher.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative 'message_formatter'
+require_relative 'slack_client'
+require_relative 'durable_slack_publisher'
+
+module CodexNotify
+  class HookThreadPublisher
+    STALE_THREAD_ERROR_CODES = %w[thread_not_found message_not_found invalid_ts].freeze
+
+    def initialize(client:, store:, outbox: nil, channel: nil)
+      @client = client
+      @store = store
+      @durable = DurableSlackPublisher.new(client:, store:, outbox:, channel:) if outbox
+    end
+
+    attr_reader :client
+
+    def ensure_thread(session_id:, root_message:)
+      return @durable.ensure_thread(key: session_id, root_message:) if @durable
+
+      thread_ts = thread_for(session_id)
+      return thread_ts if thread_ts
+
+      create_thread(session_id:, root_message:)
+    end
+
+    def publish_root_or_reply(session_id:, message:)
+      return @durable.publish_root_or_reply(key: session_id, message:) if @durable
+
+      thread_ts = thread_for(session_id)
+      return create_thread(session_id:, root_message: message) unless thread_ts
+
+      begin
+        post_message(message, thread_ts:)
+        thread_ts
+      rescue SlackClient::Error => e
+        raise unless stale_thread_error?(e)
+
+        reset_thread(session_id:)
+        create_thread(session_id:, root_message: message)
+      end
+    end
+
+    def publish_reply(session_id:, message:, recovery_root_message:)
+      if @durable
+        return @durable.publish_reply(key: session_id, message:, recovery_root_message:)
+      end
+
+      thread_ts = thread_for(session_id)
+      return unless thread_ts
+
+      begin
+        post_message(message, thread_ts:)
+        thread_ts
+      rescue SlackClient::Error => e
+        raise unless stale_thread_error?(e)
+
+        reset_thread(session_id:)
+        recovered_thread_ts = create_thread(session_id:, root_message: recovery_root_message)
+        return unless recovered_thread_ts
+
+        post_message(message, thread_ts: recovered_thread_ts)
+        recovered_thread_ts
+      end
+    end
+
+    def reset_thread(session_id:)
+      return @durable.reset(key: session_id) if @durable
+
+      @store.clear_thread(session_id)
+    end
+
+    def drain
+      @durable&.drain
+    end
+
+    private
+
+    def thread_for(session_id)
+      @store.thread_ts_for(session_id)
+    end
+
+    def create_thread(session_id:, root_message:)
+      return if root_message.nil? || root_message.body.empty?
+
+      parts = MessageFormatter.chunks(root_message).to_a
+      response = @client.post(parts.shift)
+      thread_ts = response.fetch('ts').to_s
+      @store.save_thread_ts(session_id, thread_ts)
+      post_parts(parts, thread_ts:)
+      thread_ts
+    end
+
+    def post_message(message, thread_ts:)
+      post_parts(MessageFormatter.chunks(message), thread_ts:)
+    end
+
+    def post_parts(parts, thread_ts:)
+      parts.each { |part| @client.post(part, thread_ts:) }
+    end
+
+    def stale_thread_error?(error)
+      STALE_THREAD_ERROR_CODES.include?(error.error_code)
+    end
+  end
+end

data/lib/codex_notify/log_event_parser.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module CodexNotify
+  module LogEventParser
+    module_function
+
+    def as_text(value)
+      return '' if value.nil?
+      return value if value.is_a?(String)
+      return JSON.generate(value, ascii_only: false) if value.is_a?(Hash) || value.is_a?(Array)
+
+      value.to_s
+    end
+
+    def pretty_json(value)
+      JSON.pretty_generate(value, ascii_only: false)
+    rescue StandardError
+      as_text(value)
+    end
+
+    def format_tool_payload(payload)
+      command = payload['command'] || payload['cmd'] || payload['argv']
+      stdout = payload['stdout']
+      stderr = payload['stderr']
+      exit_code = payload['exit_code']
+
+      if command.nil? && payload['info'].is_a?(Hash)
+        info = payload['info']
+        command = info['command'] || info['cmd'] || info['argv']
+        stdout ||= info['stdout']
+        stderr ||= info['stderr']
+        exit_code = info['exit_code'] if exit_code.nil?
+      end
+
+      if !command.nil? || !stdout.nil? || !stderr.nil? || !exit_code.nil?
+        command_text = command.is_a?(Array) ? command.map(&:to_s).join(' ') : (command || '').to_s
+        parts = []
+        parts << "$ #{command_text}" unless command_text.empty?
+        parts << "[exit_code] #{exit_code}" unless exit_code.nil?
+        parts << "\n[stdout]\n#{stdout}" if stdout && !stdout.empty?
+        parts << "\n[stderr]\n#{stderr}" if stderr && !stderr.empty?
+        rendered = parts.join("\n").strip
+        return rendered.empty? ? pretty_json(payload) : rendered
+      end
+
+      %w[tool_name name tool function_name].each do |key|
+        next unless payload[key]
+
+        tool_name = payload[key]
+        args = payload['arguments'] || payload['args'] || payload['input']
+        result = payload['result'] || payload['output']
+        parts = ["[tool] #{tool_name}"]
+        parts << "[args]\n#{pretty_json(args)}" unless args.nil?
+        parts << "[result]\n#{pretty_json(result)}" unless result.nil?
+        return parts.join("\n")
+      end
+
+      pretty_json(payload)
+    end
+
+    def tool_event_type?(event_type)
+      return false if event_type.nil? || event_type.to_s.empty?
+
+      %w[
+        command_execution
+        shell_command
+        tool_call
+        tool_result
+        tool
+        mcp_tool_call
+        mcp_tool_result
+        mcp_call
+        mcp_result
+        sandbox_command
+      ].include?(event_type.to_s)
+    end
+
+    def extract_events(obj)
+      events = []
+
+      if obj.is_a?(Array)
+        obj.each { |item| events.concat(extract_events(item)) }
+        return events
+      end
+
+      return events unless obj.is_a?(Hash)
+
+      object_type = obj['type']
+      if %w[input_text output_text].include?(object_type)
+        text = as_text(obj['text'] || obj['content'])
+        unless text.empty?
+          kind = object_type == 'input_text' ? 'user' : 'assistant'
+          events << [kind, text, object_type]
+        end
+        return events
+      end
+
+      payload = obj['payload']
+      if payload.is_a?(Hash)
+        payload_type = payload['type']
+
+        if tool_event_type?(payload_type)
+          events << ['tool', format_tool_payload(payload), 'tool']
+          return events
+        end
+
+        if %w[input_text output_text].include?(payload_type)
+          text = as_text(payload['text'] || payload['content'])
+          unless text.empty?
+            kind = payload_type == 'input_text' ? 'user' : 'assistant'
+            events << [kind, text, payload_type]
+          end
+          return events
+        end
+
+        if payload_type == 'message'
+          role = payload['role']
+          content = payload['content'] || payload['parts']
+
+          if content.is_a?(Array)
+            content.each do |part|
+              next unless part.is_a?(Hash)
+
+              part_type = part['type']
+              if %w[input_text output_text].include?(part_type)
+                text = as_text(part['text'] || part['content'])
+                unless text.empty?
+                  kind = part_type == 'input_text' ? 'user' : 'assistant'
+                  events << [kind, text, part_type]
+                end
+              elsif tool_event_type?(part_type)
+                events << ['tool', format_tool_payload(part), 'tool']
+              end
+            end
+          else
+            text = as_text(payload['text'])
+            if !text.empty? && %w[user assistant].include?(role)
+              inferred = role == 'user' ? 'input_text' : 'output_text'
+              events << [role, text, inferred]
+            end
+          end
+          return events
+        end
+
+        if payload_type == 'user_message'
+          text = as_text(payload['message'] || payload['text'])
+          events << ['user', text, 'input_text'] unless text.empty?
+          return events
+        end
+
+        if payload_type == 'agent_message'
+          text = as_text(payload['message'] || payload['text'])
+          events << ['assistant', text, 'output_text'] unless text.empty?
+          return events
+        end
+
+        if payload_type == 'task_complete'
+          text = as_text(payload['last_agent_message'])
+          events << ['assistant', text, 'output_text'] unless text.empty?
+          return events
+        end
+
+        nested_message = payload['message']
+        if nested_message.is_a?(Hash) || nested_message.is_a?(Array)
+          events.concat(extract_events(nested_message))
+          return events
+        end
+
+        %w[tool tool_call tool_result command_execution command].each do |key|
+          nested = payload[key]
+          next unless nested.is_a?(Hash)
+
+          nested_type = nested['type'] || key
+          if tool_event_type?(nested_type) || %w[command_execution command].include?(key)
+            events << ['tool', format_tool_payload(nested), 'tool']
+          end
+        end
+      end
+
+      %w[message item response_item response_message data].each do |key|
+        nested = obj[key]
+        events.concat(extract_events(nested)) if nested.is_a?(Hash) || nested.is_a?(Array)
+      end
+
+      events
+    end
+
+    def extract_session_id(obj)
+      return nil if obj.nil?
+
+      if obj.is_a?(Hash)
+        if obj['type'] == 'session_meta'
+          payload = obj['payload']
+          if payload.is_a?(Hash)
+            value = payload['id']
+            return value.to_s unless value.nil? || value.to_s.empty?
+          end
+        end
+
+        %w[
+          session_id
+          sessionId
+          conversation_id
+          conversationId
+          chat_id
+          chatId
+          thread_id
+          threadId
+        ].each do |key|
+          value = obj[key]
+          return value.to_s unless value.nil? || value.to_s.empty?
+        end
+
+        obj.each_value do |value|
+          session_id = extract_session_id(value)
+          return session_id if session_id
+        end
+      elsif obj.is_a?(Array)
+        obj.each do |value|
+          session_id = extract_session_id(value)
+          return session_id if session_id
+        end
+      end
+
+      nil
+    end
+  end
+end