samagotchi 0.18.1 → 0.20.0

data/lib/samagotchi/guardrails/shell_git_dirs.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "shell_lex"
+
 module Samagotchi
   module Guardrails
     # Where a shell command runs a git subcommand that changes a checkout
@@ -13,154 +15,20 @@ module Samagotchi
       MUTATING = %w[commit add reset checkout switch rebase merge push stash rm mv
                     cherry-pick revert pull restore am].freeze
       STASH_READS = %w[list show].freeze
-      # Longest first: "&&" before "&", ";;" before ";".
-      OPERATORS = ["&&", "||", ";;", "|&", ";", "|", "&", "\n", "(", ")"].freeze
       PREFIXES = %w[command builtin exec time nohup env ! { if then else elif do while until].freeze
       # git global options that take the next word as their value.
       VALUE_OPTIONS = %w[-C -c --git-dir --work-tree --namespace].freeze
-      SUBST = "\0SUBST"
-      REDIRECT = /\A\d*[<>]/
 
       # @param command [String] the shell command
       # @param cwd [String] where it starts (the call's cwd:, else the session's)
       # @param home [String] for ~, $HOME, ${HOME} and a bare cd
       # @return [Array<String, Symbol>] absolute dirs and :unknown, unique
       def self.for(command, cwd:, home: Dir.home)
-        Walk.new(cwd, home).run(simple_commands(lex(command.to_s)))
+        Walk.new(cwd, home).run(ShellLex.simple_commands(ShellLex.lex(command.to_s)))
       rescue ArgumentError, EncodingError
         [] # a NUL byte, invalid UTF-8: the shell would refuse it too
       end
 
-      # Words and operators ([:word, "x"] / [:op, "&&"]).
-      def self.lex(text)
-        Lexer.new(text).tokens
-      end
-
-      # The token stream split at operators into word lists; ( and ) become
-      # :open / :close markers.
-      def self.simple_commands(tokens)
-        commands = [[]]
-        tokens.each do |kind, value|
-          if kind == :op
-            commands << :open if value == "("
-            commands << :close if value == ")"
-            commands << []
-          else
-            commands.last << value
-          end
-        end
-        commands.reject { |c| c.is_a?(Array) && c.empty? }
-      end
-
-      # A hand-written shell lexer: quotes, backslashes, comments, $(…) and
-      # backticks (an opaque marker inside the word), redirections kept in
-      # their word (2>&1 doesn't split on &), operators.
-      class Lexer
-        def initialize(text)
-          @s = text
-          @i = 0
-          @tokens = []
-          @word = +""
-          @in_word = false
-        end
-
-        def tokens
-          step while @i < @s.size
-          flush
-          @tokens
-        end
-
-        private
-
-        def step
-          c = @s[@i]
-          case c
-          when "\\" then add(@s[@i + 1].to_s, 2)
-          when "'" then single_quote
-          when '"' then double_quote
-          when "`" then backtick
-          when "$" then @s[@i + 1] == "(" ? substitution : add(c, 1)
-          when "#" then @in_word ? add(c, 1) : comment
-          when ">", "<" then redirection
-          when " ", "\t" then flush && (@i += 1)
-          else operator_or_char(c)
-          end
-        end
-
-        def add(text, advance)
-          @word << text
-          @in_word = true
-          @i += advance
-        end
-
-        def flush
-          @tokens << [:word, @word.dup] if @in_word
-          @word.clear
-          @in_word = false
-          true
-        end
-
-        def single_quote
-          close = @s.index("'", @i + 1) || @s.size
-          add(@s[(@i + 1)...close].to_s, close + 1 - @i)
-        end
-
-        def double_quote
-          @i += 1
-          @in_word = true
-          while @i < @s.size && @s[@i] != '"'
-            if @s[@i] == "\\" && @i + 1 < @s.size
-              @word << @s[@i + 1]
-              @i += 2
-            else
-              @word << @s[@i]
-              @i += 1
-            end
-          end
-          @i += 1
-        end
-
-        def backtick
-          close = @s.index("`", @i + 1) || @s.size
-          add(SUBST, close + 1 - @i)
-        end
-
-        def substitution
-          depth = 0
-          j = @i + 1
-          loop do
-            depth += 1 if @s[j] == "("
-            depth -= 1 if @s[j] == ")"
-            j += 1
-            break if depth.zero? || j >= @s.size
-          end
-          add(SUBST, j - @i)
-        end
-
-        def comment
-          @i = @s.index("\n", @i) || @s.size
-        end
-
-        # >, >>, 2>&1, &>, <, <<: kept in the word (the walk drops them).
-        def redirection
-          add(@s[@i], 1)
-          add(@s[@i], 1) while @i < @s.size && @s[@i].match?(/[&\d>-]/) && @word.match?(/>\z/)
-        end
-
-        def operator_or_char(char)
-          op = OPERATORS.find { |o| @s[@i, o.size] == o }
-          return add(char, 1) unless op
-
-          if op == "&" && @word.match?(/\d*>\z/)
-            add(op, 1)
-          else
-            flush
-            @tokens << [:op, op]
-            @i += op.size
-          end
-        end
-      end
-
       # Follows the current dir through the simple commands and records
       # where each mutating git runs.
       class Walk
@@ -197,7 +65,7 @@ module Samagotchi
             words.shift
           end
           verb = words.shift or return
-          args = words.grep_v(REDIRECT)
+          args = words.grep_v(ShellLex::REDIRECT)
           case verb
           when "cd" then cd(args)
           when "pushd"
@@ -253,7 +121,7 @@ module Samagotchi
         # told from the text (a variable, a substitution, a relative path
         # against an unknown dir).
         def expand(arg, dir)
-          return nil if arg.include?(SUBST)
+          return nil if arg.include?(ShellLex::SUBST)
 
           arg = arg.sub(/\A(~|\$HOME|\$\{HOME\})(?=\/|\z)/) { @home }
           return nil if arg.include?("$") || arg.start_with?("~")

data/lib/samagotchi/guardrails/shell_lex.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  module Guardrails
+    # A small shell lexer for the guardrails' text checks (ShellGitDirs
+    # and the rules' shell matchers): words with quotes and
+    # backslashes undone, operators apart, comments dropped, and $(…) or
+    # backticks (quoted or not) as one opaque SUBST marker inside a word. It never runs
+    # anything, and it does its best on odd input (an unbalanced quote).
+    module ShellLex
+      # Longest first: "&&" before "&", ";;" before ";".
+      OPERATORS = ["&&", "||", ";;", "|&", ";", "|", "&", "\n", "(", ")"].freeze
+      # What a $(…) or `…` becomes inside a word.
+      SUBST = "\0SUBST"
+      # A word that is a redirection (>, >>, 2>&1, <).
+      REDIRECT = /\A\d*[<>]/
+
+      # Words and operators ([:word, "x", specials] / [:op, "&&"]). A word's
+      # specials are the characters the shell would act on in it, unquoted
+      # ("$" also when double-quoted): "$" an expansion, "{" / "}" a brace
+      # expansion, ">" / "<" a redirection.
+      def self.lex(text)
+        Lexer.new(text).tokens
+      end
+
+      # The token stream split at operators into word lists; ( and ) become
+      # :open / :close markers.
+      def self.simple_commands(tokens)
+        commands = [[]]
+        tokens.each do |kind, value|
+          if kind == :op
+            commands << :open if value == "("
+            commands << :close if value == ")"
+            commands << []
+          else
+            commands.last << value
+          end
+        end
+        commands.reject { |c| c.is_a?(Array) && c.empty? }
+      end
+
+      # A hand-written shell lexer: quotes, backslashes, comments, $(…) and
+      # backticks (an opaque marker inside the word), redirections kept in
+      # their word (2>&1 doesn't split on &), operators.
+      class Lexer
+        def initialize(text)
+          @s = text
+          @i = 0
+          @tokens = []
+          @word = +""
+          @specials = +""
+          @in_word = false
+        end
+
+        def tokens
+          step while @i < @s.size
+          flush
+          @tokens
+        end
+
+        private
+
+        def step
+          c = @s[@i]
+          case c
+          when "\\" then add(@s[@i + 1].to_s, 2)
+          when "'" then single_quote
+          when '"' then double_quote
+          when "`" then backtick
+          when "$" then @s[@i + 1] == "(" ? substitution : special(c)
+          when "#" then @in_word ? add(c, 1) : comment
+          when ">", "<" then redirection
+          when " ", "\t" then flush && (@i += 1)
+          else operator_or_char(c)
+          end
+        end
+
+        def add(text, advance)
+          @word << text
+          @in_word = true
+          @i += advance
+        end
+
+        # A character the shell acts on, kept in the word and noted.
+        def special(char)
+          @specials << char unless @specials.include?(char)
+          add(char, 1)
+        end
+
+        def flush
+          @tokens << [:word, @word.dup, @specials.dup] if @in_word
+          @word.clear
+          @specials.clear
+          @in_word = false
+          true
+        end
+
+        def single_quote
+          close = @s.index("'", @i + 1) || @s.size
+          add(@s[(@i + 1)...close].to_s, close + 1 - @i)
+        end
+
+        def double_quote
+          @i += 1
+          @in_word = true
+          while @i < @s.size && @s[@i] != '"'
+            if @s[@i] == "\\" && @i + 1 < @s.size
+              @word << @s[@i + 1]
+              @i += 2
+            elsif @s[@i] == "`" then backtick
+            elsif @s[@i] == "$" && @s[@i + 1] == "(" then substitution
+            elsif @s[@i] == "$" then special("$")
+            else
+              @word << @s[@i]
+              @i += 1
+            end
+          end
+          @i += 1
+        end
+
+        def backtick
+          close = @s.index("`", @i + 1) || @s.size
+          add(SUBST, close + 1 - @i)
+        end
+
+        def substitution
+          depth = 0
+          j = @i + 1
+          loop do
+            depth += 1 if @s[j] == "("
+            depth -= 1 if @s[j] == ")"
+            j += 1
+            break if depth.zero? || j >= @s.size
+          end
+          add(SUBST, j - @i)
+        end
+
+        def comment
+          @i = @s.index("\n", @i) || @s.size
+        end
+
+        # >, >>, 2>&1, &>, <, <<: kept in the word (the walk drops them).
+        def redirection
+          special(@s[@i])
+          add(@s[@i], 1) while @i < @s.size && @s[@i].match?(/[&\d>-]/) && @word.match?(/>\z/)
+        end
+
+        def operator_or_char(char)
+          op = OPERATORS.find { |o| @s[@i, o.size] == o }
+          return special(char) if char == "{" || char == "}"
+          return add(char, 1) unless op
+
+          if op == "&" && @word.match?(/\d*>\z/)
+            add(op, 1)
+          else
+            flush
+            @tokens << [:op, op]
+            @i += op.size
+          end
+        end
+      end
+    end
+  end
+end

data/lib/samagotchi/guardrails/shell_paths.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require_relative "shell_lex"
+require_relative "protected_paths"
+
+module Samagotchi
+  module Guardrails
+    # Whether a shell command names a path in one of some dirs (a rule's
+    # touches: chi_dirs): each word is read as a path, against the dir the
+    # command is in by then (cd, pushd/popd and ( … ) followed as in
+    # ShellGitDirs), with ~, $HOME and the XDG dirs expanded and symlinks
+    # resolved. A word names a dir when it is in it. Any path with a
+    # .git/hooks part counts too, outside the tmp dirs.
+    #
+    # A word it can't resolve (another $VAR, $(…), a glob, a relative path
+    # after cd $X) or one that reads as a script (sh -c '…', ruby -e '…':
+    # spaces, quotes, operators in it) falls back to a text match (+text+);
+    # so does the whole command when it holds a $(…) or backticks (the
+    # lexer keeps no body).
+    module ShellPaths
+      # A word that is a script rather than a path.
+      SCRIPT = /[\s;&|<>()'"`]/
+      GLOB = /[*?\[\]{}]/
+      HOOKS_PART = %r{(?:\A|/)\.git/hooks(?:/|\z)}
+      # $HOME, ${HOME} and the XDG dirs at a word's start.
+      EXPANSION = /\A\$(?:\{(HOME|XDG_[A-Z_]+|TMPDIR)\}|(HOME|XDG_[A-Z_]+|TMPDIR)\b)/
+      # Where XDG dirs default when unset.
+      XDG_DEFAULTS = { "XDG_CONFIG_HOME" => ".config", "XDG_STATE_HOME" => ".local/state",
+                       "XDG_DATA_HOME" => ".local/share", "XDG_CACHE_HOME" => ".cache" }.freeze
+      # A redirection's operator at a word's start (>>file, 2>file, <file).
+      REDIRECT_PREFIX = /\A\d*(?:&>>?|>>?&?|<)/
+
+      module_function
+
+      # @param command [String]
+      # @param dirs [Array<String>] absolute dirs (resolved here)
+      # @param text [Regexp] the fallback for a word that can't be resolved
+      # @param cwd [String, nil] where the command starts
+      # @param tmp_roots [Array<String>] where a .git/hooks part doesn't count
+      def touches?(command, dirs:, text:, cwd:, home: Dir.home, env: ENV, tmp_roots: [])
+        roots = dirs.compact.map { |dir| ProtectedPaths.real(dir.to_s.chomp("/")) }.reject(&:empty?).uniq
+        walk = Walk.new(cwd, home, env)
+        tokens = ShellLex.lex(command.to_s)
+        return true if tokens.any? { |_, value| value.include?(ShellLex::SUBST) } && command.to_s.match?(text)
+
+        ShellLex.simple_commands(tokens).any? do |words|
+          walk.step(words).any? { |word, path| path ? names?(path, roots, tmp_roots) : word.match?(text) }
+        end
+      rescue ArgumentError, EncodingError
+        command.to_s.scrub.match?(text)
+      end
+
+      def names?(path, roots, tmp_roots)
+        real = ProtectedPaths.real(path)
+        return true if roots.any? { |root| within?(real, root) }
+
+        real.match?(HOOKS_PART) && tmp_roots.none? { |tmp| within?(real, tmp) }
+      end
+
+      def within?(path, root) = path == root || path.start_with?(File.join(root, ""))
+
+      # Follows the current dir and gives, per simple command, each word
+      # with its path (nil when it can't be resolved).
+      class Walk
+        def initialize(cwd, home, env)
+          @dir = cwd
+          @home = home
+          @env = env
+          @subshells = []
+          @pushed = []
+        end
+
+        # @param words [Array<String>, Symbol] a simple command, :open or :close
+        # @return [Array<[String, String|nil]>]
+        def step(words)
+          case words
+          when :open then @subshells << @dir
+                          []
+          when :close then @dir = @subshells.pop || @dir
+                           []
+          else command(words)
+          end
+        end
+
+        # An absolute path for +word+ against the current dir, or nil.
+        def path(word) = resolve(word, @dir)
+
+        private
+
+        def command(words)
+          verb = words.find { |w| !w.match?(/\A[A-Za-z_]\w*=/) }
+          resolved = words.filter_map { |word| candidate(word) }.map { |word| [word, resolve(word, @dir)] }
+          cd_args = words.drop_while { |w| w != verb }.drop(1).grep_v(/\A-/)
+          case verb
+          when "cd" then @dir = cd_args.empty? ? @home : resolve(cd_args.first, @dir)
+          when "pushd"
+            @pushed << @dir
+            @dir = cd_args.first && resolve(cd_args.first, @dir)
+          when "popd" then @dir = @pushed.pop unless @pushed.empty?
+          end
+          resolved
+        end
+
+        # The part of +word+ that may be a path: an option's or an
+        # assignment's value, a redirection's target; nil for an option
+        # alone or an operator.
+        def candidate(word)
+          word = word.sub(REDIRECT_PREFIX, "")
+          word = word.split("=", 2).last if word.match?(/\A(--?[\w-]+|[A-Za-z_]\w*)=/)
+          return nil if word.empty? || word == "-" || word.match?(/\A-[^\/]/)
+
+          word
+        end
+
+        # An absolute path for +word+ against +dir+, or nil.
+        def resolve(word, dir)
+          return nil if word.include?(ShellLex::SUBST) || word.match?(SCRIPT)
+
+          word = expand(word) or return nil
+          return nil if word.match?(GLOB)
+          return File.expand_path(word) if word.start_with?("/")
+
+          dir && File.expand_path(word, dir)
+        end
+
+        def expand(word)
+          word = word.sub(/\A~(?=\/|\z)/) { @home }
+          word = word.sub(EXPANSION) { value(Regexp.last_match(1) || Regexp.last_match(2)) || "$" }
+          return nil if word.include?("$") || word.start_with?("~")
+
+          word
+        end
+
+        def value(name)
+          return @home if name == "HOME"
+
+          set = @env[name].to_s
+          return set unless set.empty?
+
+          XDG_DEFAULTS[name] && File.join(@home, XDG_DEFAULTS[name])
+        end
+      end
+    end
+  end
+end

data/lib/samagotchi/guardrails/targets.rb

@@ -6,6 +6,9 @@ require_relative "../log"
 require_relative "model_size"
 require_relative "outside"
 require_relative "shell_git_dirs"
+require_relative "read_only_shell"
+require_relative "shell_paths"
+require_relative "rm_targets"
 
 module Samagotchi
   module Guardrails
@@ -20,6 +23,11 @@ module Samagotchi
 
       attr_reader :tool, :command, :paths, :cwd, :repo_root
 
+      # @return [String, nil] the call's repository (Context#repo: its
+      #   common git dir, shared by its worktrees): what a "this repo"
+      #   approval is kept for
+      attr_reader :repo
+
       # @return [String] the session's repo root (the context cwd's; the cwd
       #   outside a repo): what outside_repo measures from. repo_root is the
       #   call's (its own cwd: for shell and plugin tools).
@@ -68,8 +76,10 @@ module Samagotchi
           entry = registry && registry[tool]
           args = call[:args] if entry && !entry.core? && call[:args].is_a?(Hash)
         end
-        new(tool: tool, command: command, paths: paths.compact, cwd: cwd, repo_root: context.repo_root(cwd), args: args,
-            model_name: model_name, model_key: model_key, session_root: context.repo_root(base) || base)
+        new(tool: tool, command: command, paths: paths.compact, cwd: cwd, repo_root: context.repo_root(cwd),
+            repo: context.repo(cwd), args: args,
+            model_name: model_name, model_key: model_key, session_root: context.repo_root(base) || base,
+            chi_dirs: -> { chi_dirs(context, base) })
       end
 
       # What a plugin tool's targets: callable says the call acts on:
@@ -92,6 +102,13 @@ module Samagotchi
         none
       end
 
+      # chi's own dirs (ParentApprovals.chi_dirs) and the session repo's
+      # git hooks dir.
+      def self.chi_dirs(context, base)
+        require_relative "parent_approvals"
+        ParentApprovals.chi_dirs + [context.hooks_dir(base)].compact
+      end
+
       def self.absolute(path, base)
         path = Tools::ToolPath.normalize(path)
         path.empty? ? nil : File.expand_path(path, base)
@@ -109,8 +126,11 @@ module Samagotchi
         nil
       end
 
-      def initialize(tool:, command:, paths:, cwd:, repo_root:, args: nil, model_name: nil, model_key: nil,
-                     session_root: nil)
+      # @param chi_dirs [#call, nil] → the dirs touches_chi? looks for
+      def initialize(tool:, command:, paths:, cwd:, repo_root:, repo: nil, args: nil, model_name: nil, model_key: nil,
+                     session_root: nil, chi_dirs: nil)
+        @repo = repo
+        @chi_dirs = chi_dirs
         @session_root = session_root || repo_root || cwd
         @args = args
         @model_name = model_name
@@ -124,6 +144,18 @@ module Samagotchi
 
       def shell? = SHELL_TOOLS.include?(@tool)
 
+      # The repository's name: its main checkout's folder (the folder
+      # holding the common .git dir; a bare repo's name less .git), else
+      # the repo root's folder; nil outside a repo.
+      def repo_name
+        if @repo
+          base = File.basename(@repo)
+          base == ".git" ? File.basename(File.dirname(@repo)) : base.delete_suffix(".git")
+        elsif @repo_root
+          File.basename(@repo_root)
+        end
+      end
+
       # Whether the effective model is a small one (guardrails.small_models,
       # read when first asked: once per call's targets).
       def small_model?
@@ -144,6 +176,35 @@ module Samagotchi
         @git_dirs ||= shell? ? ShellGitDirs.for(@command, cwd: @cwd) : []
       end
 
+      # Whether the command only reads (ReadOnlyShell); false without one.
+      def read_only?
+        return @read_only if defined?(@read_only)
+
+        @read_only = !@command.nil? && ReadOnlyShell.read_only?(@command)
+      end
+
+      # Whether the command names a path in chi's own dirs (ShellPaths:
+      # resolved paths; the text CHI_SHELL_TEXT for a word that can't be
+      # resolved); false without a command.
+      def touches_chi?
+        return @touches_chi if defined?(@touches_chi)
+
+        @touches_chi = !@command.nil? && begin
+          require_relative "parent_approvals"
+          ShellPaths.touches?(@command, dirs: @chi_dirs ? @chi_dirs.call : ParentApprovals.chi_dirs,
+                                        text: ParentApprovals::CHI_SHELL_TEXT, cwd: @cwd, tmp_roots: Outside.tmp_roots)
+        end
+      end
+
+      # Whether an rm -rf in the command reaches outside the tmp dirs
+      # (RmTargets; a tmp dir the session's root is in doesn't count as one).
+      def rm_outside_tmp?
+        return @rm_outside_tmp if defined?(@rm_outside_tmp)
+
+        @rm_outside_tmp = !@command.nil? &&
+                          RmTargets.outside_tmp?(@command, cwd: @cwd, tmp_roots: Outside.tmp_roots, session_root: @session_root)
+      end
+
       # Whether a shell call runs mutating git outside the session's repo
       # (an :unknown dir doesn't count).
       def git_outside_repo?

data/lib/samagotchi/guardrails.rb

@@ -3,7 +3,9 @@
 require_relative "guardrails/verdict"
 require_relative "guardrails/context"
 require_relative "guardrails/outside"
+require_relative "guardrails/shell_lex"
 require_relative "guardrails/shell_git_dirs"
+require_relative "guardrails/read_only_shell"
 require_relative "guardrails/targets"
 require_relative "guardrails/model_size"
 require_relative "guardrails/approval"

data/lib/samagotchi/hooks/registry.rb

@@ -257,8 +257,10 @@ module Samagotchi
           event[:hook] = label if event.is_a?(Hash)
           begin
             hook_proc.call(event)
-          rescue StandardError
+          rescue StandardError => e
             # A failing hook must not break the turn.
+            Log.exception(:hooks, "hook_failed", e, echo: "[samagotchi:hooks] #{label} failed: #{e.class}: #{e.message}",
+                                                hook: label, event: name.to_s)
           end
         end
       end
@@ -284,8 +286,10 @@ module Samagotchi
           event[:hook] = label if event.is_a?(Hash)
           begin
             hook_proc.call(event)
-          rescue StandardError
+          rescue StandardError => e
             # A failing hook must not break the turn.
+            Log.exception(:hooks, "hook_failed", e, echo: "[samagotchi:hooks] #{label} failed: #{e.class}: #{e.message}",
+                                                hook: label, event: name.to_s)
           end
           yield event
         end