oops-cli 0.1.0

data/lib/oops/formatter.rb

@@ -0,0 +1,115 @@
+module Oops
+  # Turns captured records into the paste-ready clipboard text.
+  #
+  # Per field (command line and output) the pipeline is: strip ANSI, scrub
+  # invalid UTF-8, shorten the home directory to "~", mask secrets, apply the
+  # config replace table. Output is then truncated (head/tail) and fenced.
+  # With show_secrets, the home/mask/replace steps are skipped.
+  class Formatter
+    GITHUB_COLLAPSE_LINES = 30
+
+    # lines: output lines shown after formatting, summed over records. The
+    # "... N lines omitted ..." marker is not counted.
+    # command_line: the formatted first command, without "$ " or indentation.
+    Result = Struct.new(:text, :lines, :masked_count, :command_line)
+
+    def initialize(config:, home: Dir.home, show_secrets: false, head: nil, tail: nil, github: false)
+      @config = config
+      @home = home.to_s
+      @show_secrets = show_secrets
+      @head = head
+      @tail = tail
+      @github = github
+      @masked = 0
+    end
+
+    def format(records)
+      @masked = 0
+      blocks = records.map { |record| build_block(record) }
+      text = @github ? blocks.map { |b| github_block(b) }.join("\n") : plain_text(blocks)
+      Result.new(text, blocks.sum { |b| b[:count] }, @masked, blocks.first&.dig(:command))
+    end
+
+    private
+
+    def build_block(record)
+      command = clean(record.cmd.to_s).sub(/\s+\z/, "")
+      shown, count = shown_lines(clean(PromptSp.strip(record.output.to_s)))
+      exit_code = record.exit
+      exit_code = nil if exit_code.to_i.zero?
+      body = ["$ #{command.gsub("\n", "\n  ").gsub(/^ +$/, '')}", *shown]
+      body << "(exit #{exit_code})" if exit_code
+      { command: command, exit: exit_code, count: count, content: body.join("\n") }
+    end
+
+    # Returns [lines to show, real output line count]: trailing blank lines
+    # dropped, then head/tail truncation.
+    def shown_lines(text)
+      lines = text.split("\n", -1)
+      lines.pop while lines.any? && lines.last.strip.empty?
+      shown = truncate(lines)
+      [shown, shown.equal?(lines) ? lines.size : shown.size - 1]
+    end
+
+    def truncate(lines)
+      return lines if @head.nil? && @tail.nil?
+
+      head = @head.to_i
+      tail = @tail.to_i
+      omitted = lines.size - head - tail
+      return lines if omitted <= 0
+
+      marker = "... #{omitted.to_s.reverse.scan(/\d{1,3}/).join(',').reverse} lines omitted ..."
+      [*lines.first(head), marker, *(tail.zero? ? [] : lines.last(tail))]
+    end
+
+    def clean(raw)
+      text = Ansi.strip(raw.dup).force_encoding(Encoding::UTF_8).scrub
+      return text if @show_secrets
+
+      text = shorten_home(text)
+      text, count = Secrets.mask(text, extra: @config.secrets)
+      @masked += count
+      apply_replace(text)
+    end
+
+    def shorten_home(text)
+      return text if @home.empty? || @home == "/"
+
+      text.gsub(/#{Regexp.escape(@home)}(?!\w)/, "~")
+    end
+
+    def apply_replace(text)
+      keys = @config.replace.keys.reject(&:empty?).sort_by { |k| -k.length }
+      return text if keys.empty?
+
+      table = @config.replace
+      text.gsub(Regexp.union(keys)) { |match| table[match] }
+    end
+
+    def plain_text(blocks)
+      fenced(blocks.map { |b| b[:content] }.join("\n\n"), "")
+    end
+
+    def github_block(block)
+      fence = fenced(block[:content], "console")
+      return fence if block[:count] <= GITHUB_COLLAPSE_LINES
+
+      parts = []
+      parts << "exit #{block[:exit]}" if block[:exit]
+      parts << "#{block[:count]} lines"
+      summary = escape_html("$ #{block[:command]}".gsub("\n", " "))
+      "<details>\n<summary><code>#{summary}</code> — #{parts.join(', ')}</summary>\n\n#{fence}\n</details>\n"
+    end
+
+    def fenced(content, language)
+      longest = content.scan(/`+/).map(&:length).max.to_i
+      fence = "`" * [3, longest + 1].max
+      "#{fence}#{language}\n#{content}\n#{fence}\n"
+    end
+
+    def escape_html(text)
+      text.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;")
+    end
+  end
+end

data/lib/oops/marker.rb

@@ -0,0 +1,88 @@
+# APC marker layout
+#
+# The shell hooks write these markers into the terminal stream and the pty
+# relay extracts them again. Because they are APC sequences, terminals ignore
+# them. Byte layout:
+#
+#   PREFIX  ESC _ o o p s ;        ("\e_oops;")
+#   body    <kind> [; <field> ...]
+#   SUFFIX  ESC \                  ("\e\\")
+#
+# Fields are separated by ";". Free-form text (cwd, cmd) is strict base64
+# (RFC 4648, no line breaks), so it never contains ";", ESC or a newline.
+#
+#   start;<seq>;<epoch>;<b64 cwd>;<b64 cmd>   command is about to run
+#   end;<seq>;<exit>                          command finished
+#   pause                                     stop recording (e.g. full-screen UI)
+#   resume                                    start recording again
+#
+# <seq>, <epoch> and <exit> are decimal integers. Example:
+#
+#   printf '\033_oops;start;%s;%s;%s;%s\033\\' "$seq" "$(date +%s)" \
+#     "$(printf '%s' "$PWD" | base64 | tr -d '\n')" \
+#     "$(printf '%s' "$cmd" | base64 | tr -d '\n')"
+#
+# Marker.parse takes the text between "ESC _" and "ESC \", i.e. it starts with
+# "oops;".
+module Oops
+  module Marker
+    PREFIX = "\e_oops;".b.freeze
+    SUFFIX = "\e\\".b.freeze
+
+    UINT = /\A\d+\z/
+    INT = /\A-?\d+\z/
+
+    def self.start(seq:, started_at:, cwd:, cmd:)
+      wrap("start;#{seq};#{started_at};#{encode(cwd)};#{encode(cmd)}")
+    end
+
+    def self.end(seq:, exit:)
+      wrap("end;#{seq};#{exit}")
+    end
+
+    def self.pause = wrap("pause")
+    def self.resume = wrap("resume")
+
+    # Returns a Hash for a well-formed payload, nil for anything else.
+    def self.parse(payload)
+      return nil unless payload.is_a?(String)
+
+      fields = payload.b.split(";", -1)
+      return nil unless fields.shift == "oops"
+
+      case fields.shift
+      when "start" then parse_start(fields)
+      when "end" then parse_end(fields)
+      when "pause" then fields.empty? ? { kind: :pause } : nil
+      when "resume" then fields.empty? ? { kind: :resume } : nil
+      end
+    end
+
+    def self.parse_start(fields)
+      return nil unless fields.size == 4 && fields[0].match?(UINT) && fields[1].match?(UINT)
+
+      cwd = decode(fields[2])
+      cmd = decode(fields[3])
+      return nil unless cwd && cmd
+
+      { kind: :start, seq: fields[0].to_i, started_at: fields[1].to_i, cwd: cwd, cmd: cmd }
+    end
+
+    def self.parse_end(fields)
+      return nil unless fields.size == 2 && fields[0].match?(UINT) && fields[1].match?(INT)
+
+      { kind: :end, seq: fields[0].to_i, exit: fields[1].to_i }
+    end
+
+    def self.wrap(body) = "#{PREFIX}#{body}#{SUFFIX}"
+    def self.encode(text) = [text.to_s.b].pack("m0")
+
+    def self.decode(text)
+      text.unpack1("m0").force_encoding(Encoding::UTF_8).scrub
+    rescue ArgumentError
+      nil
+    end
+
+    private_class_method :parse_start, :parse_end, :wrap, :encode, :decode
+  end
+end

data/lib/oops/paths.rb

@@ -0,0 +1,28 @@
+require "fileutils"
+
+module Oops
+  # Filesystem locations following the XDG base directory spec.
+  module Paths
+    module_function
+
+    def config_file(env: ENV)
+      File.join(base(env, "XDG_CONFIG_HOME", ".config"), "oops", "config.yml")
+    end
+
+    def sessions_dir(env: ENV)
+      File.join(base(env, "XDG_STATE_HOME", ".local/state"), "oops", "sessions")
+    end
+
+    def ensure_sessions_dir!(env: ENV)
+      dir = sessions_dir(env: env)
+      FileUtils.mkdir_p(dir, mode: 0o700)
+      File.chmod(0o700, dir)
+      dir
+    end
+
+    def base(env, key, fallback)
+      value = env[key]
+      value.nil? || value.empty? ? File.join(Dir.home, fallback) : value
+    end
+  end
+end

data/lib/oops/prompt_sp.rb

@@ -0,0 +1,74 @@
+module Oops
+  # Removes the PROMPT_SP filler that zsh writes at the end of a command's
+  # output.
+  #
+  # Before it draws a prompt (and before precmd, so before our end marker),
+  # zsh with PROMPT_SP and PROMPT_CR set (the default) writes:
+  #
+  #   <PROMPT_EOL_MARK> <columns - W - (0 or 1) spaces> CR <W spaces> CR
+  #
+  # where W is the display width of the expanded mark (default "%B%S%#%s%b",
+  # a bold inverse "%" or "#"). On a terminal this leaves the mark after
+  # output that did not end in a newline and moves the prompt to a fresh
+  # line. In a record it is noise, and worse: line-control handling keeps the
+  # text after the last CR (" "), so a last line without a newline is lost.
+  #
+  # Only an exact trailing match is removed: the CR / spaces / CR shape, a
+  # mark of width W right before the spaces, and mark plus spaces at least
+  # MIN_COLUMNS wide (the filler spans the terminal). Assumes a mark that
+  # does not end in spaces.
+  module PromptSp
+    MIN_COLUMNS = 20
+    FILLER = /(?<! )( ++)\r( *+)\r\z/n
+    TOKEN = Regexp.union(Ansi::ESCAPES, /[\xC2-\xF4][\x80-\xBF]*|./mn)
+    WIDE = [
+      0x1100..0x115F, 0x2E80..0x303E, 0x3041..0x33FF, 0x3400..0x4DBF, 0x4E00..0x9FFF,
+      0xA000..0xA4CF, 0xAC00..0xD7A3, 0xF900..0xFAFF, 0xFE30..0xFE4F, 0xFF00..0xFF60,
+      0xFFE0..0xFFE6, 0x1F300..0x1F64F, 0x1F900..0x1F9FF, 0x20000..0x3FFFD
+    ].freeze
+
+    module_function
+
+    # Returns bytes without a trailing filler, or bytes unchanged.
+    def strip(bytes)
+      raw = bytes.b
+      m = FILLER.match(raw)
+      return bytes unless m
+
+      width = m[2].bytesize
+      return bytes if width + m[1].bytesize < MIN_COLUMNS
+
+      before = raw.byteslice(0, m.begin(0))
+      line_start = (before.rindex("\n") || -1) + 1
+      tokens = before.byteslice(line_start..).scan(TOKEN)
+      tokens = drop_mark(tokens, width)
+      return bytes unless tokens
+
+      (before.byteslice(0, line_start) + tokens.join).force_encoding(bytes.encoding)
+    end
+
+    # Pops the mark (width display columns) and the escape sequences around
+    # it off the end of the line's tokens; nil if the line is too short.
+    def drop_mark(tokens, width)
+      tokens = tokens.dup
+      while width.positive?
+        token = tokens.pop
+        return nil unless token
+
+        width -= token_width(token)
+      end
+      tokens.pop while tokens.any? && token_width(tokens.last).zero?
+      tokens
+    end
+
+    def token_width(token)
+      return 0 if token.start_with?("\e", "\a")
+      return 1 if token.bytesize == 1
+
+      char = token.dup.force_encoding(Encoding::UTF_8)
+      return 1 unless char.valid_encoding?
+
+      WIDE.any? { |range| range.cover?(char.ord) } ? 2 : 1
+    end
+  end
+end

data/lib/oops/record.rb

@@ -0,0 +1,41 @@
+require "json"
+
+module Oops
+  # One captured command with its output, stored as a single JSON line.
+  Record = Struct.new(:seq, :cmd, :cwd, :started_at, :ended_at, :exit, :output,
+                      :dropped_bytes, :fullscreen, keyword_init: true) do
+    def to_json_line
+      h = to_h
+      h[:cmd] = utf8_clean(cmd)
+      h[:cwd] = utf8_clean(cwd)
+      h[:output] = [output.to_s.b].pack("m0")
+      "#{JSON.generate(h)}\n"
+    end
+
+    def utf8_clean(value)
+      return nil if value.nil?
+
+      value.to_s.dup.force_encoding(Encoding::UTF_8).scrub
+    end
+    private :utf8_clean
+
+    def oops_self?
+      cmd.to_s.match?(%r{\A\s*(\S*/)?oops(\s|\z)})
+    end
+
+    def self.from_json_line(line)
+      h = JSON.parse(line)
+      raise Record::ParseError, "record is not an object" unless h.is_a?(Hash)
+
+      new(**h.slice(*members.map(&:to_s)).transform_keys(&:to_sym),
+          output: h["output"].to_s.unpack1("m0"))
+    rescue JSON::ParserError, ArgumentError => e
+      raise Record::ParseError, e.message
+    end
+  end
+
+  # Raised when a session log line cannot be decoded into a Record.
+  class Record
+    class ParseError < StandardError; end
+  end
+end