samagotchi 0.128.0 → 0.130.0

data/lib/samagotchi/guardrails/rm_targets.rb

@@ -2,7 +2,7 @@
 
 require_relative "shell_lex"
 require_relative "shell_paths"
-require_relative "protected_paths"
+require_relative "path_resolve"
 
 module Samagotchi
   module Guardrails
@@ -38,8 +38,8 @@ module Samagotchi
         code = ShellLex.code_text(command.to_s)
         return true if tokens.any? { |_, value| value.include?(ShellLex::SUBST) } && code.match?(/\brm\b/)
 
-        session = ProtectedPaths.real(session_root.to_s)
-        roots = tmp_roots.reject { |tmp| ShellPaths.within?(session, tmp) }
+        session = PathResolve.real(session_root.to_s)
+        roots = PathResolve.tmp_roots(session: session, roots: tmp_roots)
         walk = ShellPaths::Walk.new(cwd, home, env)
         ShellLex.simple_commands(tokens).any? do |words|
           wide = words.is_a?(Array) && words.any?(&RM_WORD) && wide?(words, walk, roots)
@@ -61,9 +61,10 @@ module Samagotchi
         return false unless options.any? { |o| o.match?(RECURSIVE) } && options.any? { |o| o.match?(FORCE) }
 
         targets.empty? || targets.any? do |target|
-          path = walk.path(target)
-          real = path && ProtectedPaths.real(path)
-          real.nil? || roots.none? { |tmp| real.start_with?(File.join(tmp, "")) }
+          paths = walk.paths(target)
+          paths.empty? || paths.flat_map { |path| PathResolve.reals(path) }.any? do |real|
+            roots.none? { |tmp| PathResolve.strictly_under?(real, tmp, fold: File.exist?(tmp)) }
+          end
         end
       end
 

data/lib/samagotchi/guardrails/rules.rb

@@ -16,9 +16,12 @@ module Samagotchi
     #   command: a Ruby regex on a shell tool's command, the body of a
     #            heredoc its command only reads as data left out
     #            (Targets#rule_command, ShellLex.code_text)
-    #   path:    "outside_repo", or a glob on the resolved paths (absolute
-    #            or "**/…" globs match the absolute path; others the path
-    #            relative to the repo root, the cwd outside one)
+    #   path:    "outside_repo", or a glob on the paths (absolute or "**/…"
+    #            globs match the absolute path; others the path relative
+    #            to the repo root, the cwd outside one): as typed
+    #            (Targets#paths) and, for an ask or deny, as they resolve
+    #            (PathResolve.reals, relative to the root as it resolves),
+    #            so a symlink into .git/hooks doesn't slip past a hooks rule
     #   git:     "outside_repo": a shell call runs a mutating git
     #            subcommand outside the session's repo (ShellGitDirs)
     #   models:  "small" (Guardrails::ModelSize, guardrails.small_models),
@@ -102,12 +105,27 @@ module Samagotchi
 
           base = targets.repo_root || targets.cwd
           glob = path.start_with?("~") ? File.expand_path(path) : path
+          absolute = glob.start_with?("/", "**")
+          real_base = nil
           targets.paths.any? do |p|
-            candidate = glob.start_with?("/", "**") ? p : relative(p, base)
-            candidate && File.fnmatch(glob, candidate, GLOB_FLAGS)
+            forms = [[p, base]]
+            # A resolved match only adds an ask or a deny; were a verdict
+            # ever to let a call through, a symlink into its glob must not.
+            if resolved_match?
+              real_base ||= PathResolve.real(base)
+              forms += PathResolve.reals(p).map { |real| [real, real_base] }
+            end
+            forms.any? do |form, from|
+              candidate = absolute ? form : relative(form, from)
+              candidate && File.fnmatch(glob, candidate, GLOB_FLAGS)
+            end
           end
         end
 
+        # Whether a path: glob also matches the paths as they resolve: for
+        # an ask or a deny only.
+        def resolved_match? = VERDICTS.include?(verdict.to_s)
+
         def relative(path, base)
           prefix = File.join(base, "")
           path.start_with?(prefix) ? path.delete_prefix(prefix) : nil

data/lib/samagotchi/guardrails/scratch_writes.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "path_resolve"
 require_relative "protected_paths"
 require_relative "../memory_paths"
 
@@ -33,7 +34,9 @@ module Samagotchi
         targets = verdict.targets
         return false unless targets && %w[write edit].include?(targets.tool)
 
-        targets.paths.any? { |path| ProtectedPaths.within?(ProtectedPaths.real(path), @memories_dir.call) }
+        targets.paths.flat_map { |path| PathResolve.reals(path) }.any? do |real|
+          PathResolve.within?(real, @memories_dir.call)
+        end
       end
     end
   end

data/lib/samagotchi/guardrails/shell_git_dirs.rb

@@ -1,16 +1,27 @@
 # frozen_string_literal: true
 
 require_relative "shell_lex"
+require_relative "path_resolve"
+require_relative "shell_paths"
 
 module Samagotchi
   module Guardrails
     # Where a shell command runs a git subcommand that changes a checkout
     # (commit, add, reset, …): the directories, or :unknown for one that
-    # can't be read from the text ($VAR, $(…), `cd -`). Pure text: it
-    # follows cd/pushd/popd, ( … ) subshells, git -C/--git-dir/--work-tree
-    # and GIT_DIR/GIT_WORK_TREE. It catches honest mistakes (cd into
-    # another checkout and commit there); sh -c, scripts, aliases and
-    # $(…) bodies get through. Never raises on odd input.
+    # can't be read from the text ($VAR, $(…), `cd -`). Read from the text:
+    # it follows cd/pushd/popd, ( … ) subshells, git -C/--git-dir/--work-tree
+    # and GIT_DIR/GIT_WORK_TREE. Where a `..` climbs out of a symlinked
+    # dir's target, its lexical path and its physical one
+    # (PathResolve.expand, the only look at the disk) both count: a cd
+    # may land at either (the shell's logical cd chdirs to the physical
+    # path when the logical one doesn't exist, and always with -P), so the
+    # walk keeps every dir the command may be in, and git's -C and dir
+    # options are opened the kernel's way; such a git counts from each. A
+    # leading ~, $HOME, XDG dir or $TMPDIR is expanded as ShellPaths::Walk
+    # expands it (PathResolve.expand_word). It
+    # catches honest mistakes (cd into another checkout and commit
+    # there); sh -c, scripts, aliases and $(…) bodies get through. Never
+    # raises on odd input.
     module ShellGitDirs
       MUTATING = %w[commit add reset checkout switch rebase merge push stash rm mv
                     cherry-pick revert pull restore am].freeze
@@ -22,9 +33,13 @@ module Samagotchi
       # @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
+      # @param env [Hash{String=>String}] the call's env: (task_create's):
+      #   its GIT_DIR / GIT_WORK_TREE hold for each git unless it sets its own
+      # @param vars [Hash{String=>String}] the shell's variables a word's
+      #   $XDG_* / $TMPDIR expand from (ENV, with the call's env: over it)
       # @return [Array<String, Symbol>] absolute dirs and :unknown, unique
-      def self.for(command, cwd:, home: Dir.home)
-        Walk.new(cwd, home).run(ShellLex.simple_commands(ShellLex.lex(command.to_s)))
+      def self.for(command, cwd:, home: Dir.home, env: {}, vars: ENV)
+        Walk.new(cwd, home, env, vars).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
@@ -32,9 +47,14 @@ module Samagotchi
       # Follows the current dir through the simple commands and records
       # where each mutating git runs.
       class Walk
-        def initialize(cwd, home)
-          @dir = cwd
+        # More dirs than this after a cd: the dir is unknown.
+        MAX_DIRS = 8
+
+        def initialize(cwd, home, env = {}, vars = ENV)
+          @dirs = [cwd]
           @home = home
+          @vars = vars
+          @env = env.slice("GIT_DIR", "GIT_WORK_TREE")
           @subshells = []
           @pushed = []
           @found = []
@@ -43,8 +63,8 @@ module Samagotchi
         def run(commands)
           commands.each do |words|
             case words
-            when :open then @subshells << @dir
-            when :close then @dir = @subshells.pop || @dir
+            when :open then @subshells << @dirs
+            when :close then @dirs = @subshells.pop || @dirs
             else simple(words.dup)
             end
           end
@@ -54,7 +74,7 @@ module Samagotchi
         private
 
         def simple(words)
-          env = {}
+          env = @env.dup
           while (word = words.first)
             if word.match?(/\A[A-Za-z_]\w*=/)
               key, value = word.split("=", 2)
@@ -69,46 +89,63 @@ module Samagotchi
           case verb
           when "cd" then cd(args)
           when "pushd"
-            @pushed << @dir
-            @dir = args.first ? expand(args.first, @dir) : nil
-          when "popd" then @dir = @pushed.pop unless @pushed.empty?
+            @pushed << @dirs
+            @dirs = args.first ? dirs_after(args.first) : [nil]
+          when "popd" then @dirs = @pushed.pop unless @pushed.empty?
           else git(args, env) if verb == "git" || verb.end_with?("/git")
           end
         end
 
         def cd(args)
           target = args.reject { |a| %w[-P -L -e -@].include?(a) }.first
-          @dir = if target.nil? then @home
-                 elsif target == "-" then nil
-                 else expand(target, @dir)
-                 end
+          @dirs = if target.nil? then [@home]
+                  elsif target == "-" then [nil]
+                  else dirs_after(target)
+                  end
+        end
+
+        # Every dir a cd to +target+ may land at from each current one: its
+        # lexical path and its physical one (nil for one it can't tell);
+        # [nil] past MAX_DIRS.
+        def dirs_after(target)
+          dirs = @dirs.flat_map { |dir| [false, true].map { |physical| expand(target, dir, physical: physical) } }.uniq
+          dirs.size > MAX_DIRS ? [nil] : dirs
         end
 
         def git(args, env)
-          dir = @dir
-          work_tree = env["GIT_WORK_TREE"] && expand(env["GIT_WORK_TREE"], dir)
-          git_dir = env["GIT_DIR"] && expand(env["GIT_DIR"], dir)
+          @found.concat(@dirs.product([false, true]).filter_map do |dir, physical|
+            where_git(args.dup, env, dir, physical)
+          end)
+        end
+
+        # Where a mutating git run from +dir+ runs (a dir or :unknown), nil
+        # for another git; +physical+: its dir options' `..` taken the
+        # kernel's way.
+        def where_git(args, env, dir, physical)
+          expand = ->(arg, base) { expand(arg, base, physical: physical) }
+          work_tree = env["GIT_WORK_TREE"] && expand.call(env["GIT_WORK_TREE"], dir)
+          git_dir = env["GIT_DIR"] && expand.call(env["GIT_DIR"], dir)
           sub = nil
           until args.empty?
             arg = args.shift
             case arg
             when *VALUE_OPTIONS
               value = args.shift.to_s
-              dir = expand(value, dir) if arg == "-C"
-              git_dir = expand(value, dir) if arg == "--git-dir"
-              work_tree = expand(value, dir) if arg == "--work-tree"
-            when /\A--git-dir=(.*)\z/m then git_dir = expand(Regexp.last_match(1), dir)
-            when /\A--work-tree=(.*)\z/m then work_tree = expand(Regexp.last_match(1), dir)
+              dir = expand.call(value, dir) if arg == "-C"
+              git_dir = expand.call(value, dir) if arg == "--git-dir"
+              work_tree = expand.call(value, dir) if arg == "--work-tree"
+            when /\A--git-dir=(.*)\z/m then git_dir = expand.call(Regexp.last_match(1), dir)
+            when /\A--work-tree=(.*)\z/m then work_tree = expand.call(Regexp.last_match(1), dir)
             when /\A-/ then next
             else
               sub = arg
               break
             end
           end
-          return unless MUTATING.include?(sub)
-          return if sub == "stash" && STASH_READS.include?(args.first)
+          return nil unless MUTATING.include?(sub)
+          return nil if sub == "stash" && STASH_READS.include?(args.first)
 
-          @found << (work_tree || repo_of(git_dir) || dir || :unknown)
+          work_tree || repo_of(git_dir) || dir || :unknown
         end
 
         def repo_of(git_dir)
@@ -117,17 +154,17 @@ module Samagotchi
           File.basename(git_dir) == ".git" ? File.dirname(git_dir) : git_dir
         end
 
-        # An absolute path for +arg+ against +dir+; nil when it can't be
-        # told from the text (a variable, a substitution, a relative path
-        # against an unknown dir).
-        def expand(arg, dir)
+        # An absolute path for +arg+ against +dir+ (`..` lexical, or
+        # +physical+: PathResolve.expand); nil when it can't
+        # be told from the text (a variable but those PathResolve.expand_word
+        # expands, a substitution, a relative path against an unknown dir).
+        def expand(arg, dir, physical: false)
           return nil if arg.include?(ShellLex::SUBST)
 
-          arg = arg.sub(%r{\A(~|\$HOME|\$\{HOME\})(?=/|\z)}) { @home }
-          return nil if arg.include?("$") || arg.start_with?("~")
-          return File.expand_path(arg) if arg.start_with?("/")
+          arg = PathResolve.expand_word(arg, home: @home, env: @vars) or return nil
+          return nil unless arg.start_with?("/") || dir
 
-          dir && File.expand_path(arg, dir)
+          physical ? PathResolve.expand(arg, dir) : File.expand_path(arg, dir)
         end
       end
     end

data/lib/samagotchi/guardrails/shell_lex.rb

@@ -114,7 +114,7 @@ module Samagotchi
           end
           redirected ||= exec_redirect?(tokens, indices, words)
         end
-        cuts.sort_by { |span, _| -span.begin }.each_with_object(+text) do |(span, replacement), out|
+        cuts.sort_by { |span, _| -span.begin }.each_with_object(text.dup) do |(span, replacement), out|
           out[span] = replacement
         end
       rescue ArgumentError, EncodingError

data/lib/samagotchi/guardrails/shell_paths.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "shell_lex"
-require_relative "protected_paths"
+require_relative "path_resolve"
 require_relative "../redacted_inspect"
 
 module Samagotchi
@@ -24,11 +24,10 @@ module Samagotchi
       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)/
+      # $HOME, ${HOME} and the XDG dirs at a word's start (PathResolve's).
+      EXPANSION = PathResolve::EXPANSION
       # 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
+      XDG_DEFAULTS = PathResolve::XDG_DEFAULTS
       # A redirection's operator at a word's start (>>file, 2>file, <file).
       REDIRECT_PREFIX = /\A\d*(?:&>>?|>>?&?|<)/
 
@@ -40,7 +39,7 @@ module Samagotchi
       # @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
+        roots = dirs.compact.map { |dir| PathResolve.real(dir.to_s.chomp("/")) }.reject(&:empty?).uniq
         any_path?(command, text: text, cwd: cwd, home: home, env: env) { |path| names?(path, roots, tmp_roots) }
       end
 
@@ -48,7 +47,8 @@ module Samagotchi
       # word resolved as #touches? resolves it); a word that can't be
       # resolved, a command with a $(…) or backticks, or one that doesn't
       # lex, by the text match +text+ instead.
-      # @yieldparam path [String] an absolute path (not resolved for symlinks)
+      # @yieldparam path [String] an absolute path (not resolved for
+      #   symlinks but for a `..` climbing out of one: Walk)
       def any_path?(command, text:, cwd:, home: Dir.home, env: ENV)
         walk = Walk.new(cwd, home, env)
         tokens = ShellLex.lex(command.to_s)
@@ -63,21 +63,37 @@ module Samagotchi
       end
 
       def names?(path, roots, tmp_roots)
-        real = ProtectedPaths.real(path)
-        return true if roots.any? { |root| within?(real, root) }
+        PathResolve.reals(path).any? do |real|
+          next true if roots.any? { |root| PathResolve.under?(real, root) }
 
-        real.match?(HOOKS_PART) && tmp_roots.none? { |tmp| within?(real, tmp) }
+          real.match?(HOOKS_PART) && tmp_roots.none? { |tmp| PathResolve.under?(real, tmp) }
+        end
       end
 
-      def within?(path, root) = path == root || path.start_with?(File.join(root, ""))
+      # Whether +path+ is +root+ or in it, cased alike on a disk that folds
+      # case (PathResolve.under?).
+      def within?(path, root) = PathResolve.under?(path, root)
 
       # Follows the current dir and gives, per simple command, each word
-      # with its path (nil when it can't be resolved).
+      # with its path (nil when it can't be resolved). A word is opened the
+      # kernel's way, so a `..` after a symlinked dir climbs out of its
+      # target: such a word comes twice, with its lexical path and its
+      # physical one (PathResolve.expand), and a check reads both. A cd
+      # or pushd to such a word may land at either (the shell's logical cd
+      # chdirs to the physical path when the logical one doesn't exist, and
+      # always with -P, set -P or zsh's chase_links/chase_dots), so the walk
+      # keeps every dir the command may be in by then and resolves later
+      # words against each (a word not resolvable from one of them isn't
+      # resolved). A symlink without a `..` lands at the same file either
+      # way.
       class Walk
         include RedactedInspect
 
+        # More dirs than this after a cd: the dir is unknown.
+        MAX_DIRS = 8
+
         def initialize(cwd, home, env)
-          @dir = cwd
+          @dirs = [cwd]
           @home = home
           @env = env
           @subshells = []
@@ -88,45 +104,78 @@ module Samagotchi
         # @return [Array<[String, String|nil]>]
         def step(words)
           case words
-          when :open then @subshells << @dir
+          when :open then @subshells << @dirs
                           []
-          when :close then @dir = @subshells.pop || @dir
+          when :close then @dirs = @subshells.pop || @dirs
                            []
           else command(words)
           end
         end
 
-        # An absolute path for +word+ against the current dir, or nil.
-        def path(word) = resolve(word, @dir)
+        # Every dir the command may be in by now (nil for one it can't tell).
+        def dirs = @dirs.dup
+
+        # 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?(%r{\A-[^/]})
+
+          word
+        end
+
+        # The absolute paths for +word+ against every dir the command may be
+        # in (.paths_for), [] when it can't be resolved from one of them.
+        def paths(word)
+          found = @dirs.map { |dir| paths_for(word, dir) }
+          found.any?(&:empty?) ? [] : found.flatten.uniq
+        end
 
         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-/)
+          cd_args = words.drop_while { |w| w != verb }.drop(1).grep_v(/\A-./)
+          resolved = words.filter_map { |word| candidate(word) }.flat_map do |word|
+            paths = paths(word)
+            paths.empty? ? [[word, nil]] : paths.map { |path| [word, path] }
+          end
           case verb
-          when "cd" then @dir = cd_args.empty? ? @home : resolve(cd_args.first, @dir)
+          when "cd" then @dirs = cd_args.empty? ? [@home] : dirs_after(cd_args.first)
           when "pushd"
-            @pushed << @dir
-            @dir = cd_args.first && resolve(cd_args.first, @dir)
-          when "popd" then @dir = @pushed.pop unless @pushed.empty?
+            @pushed << @dirs
+            @dirs = cd_args.first ? dirs_after(cd_args.first) : [nil]
+          when "popd" then @dirs = @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?(%r{\A-[^/]})
+        # Every dir a cd to +word+ may land at, from each current one (nil
+        # for one it can't tell: `cd -` among them); [nil] past MAX_DIRS.
+        def dirs_after(word)
+          return [nil] if word == "-"
 
-          word
+          dirs = @dirs.flat_map do |dir|
+            found = paths_for(word, dir)
+            found.empty? ? [nil] : found
+          end.uniq
+          dirs.size > MAX_DIRS ? [nil] : dirs
+        end
+
+        # +word+ as a file argument against +dir+: its lexical path, and its
+        # physical one when a `..` in it climbs out of a symlinked dir's
+        # target (PathResolve.expand); [] when it can't be resolved.
+        def paths_for(word, dir)
+          lexical = resolve(word, dir) or return []
+          return [lexical] unless word.include?("..")
+
+          [lexical, PathResolve.expand(expand(word), dir)].uniq
         end
 
-        # An absolute path for +word+ against +dir+, or nil.
+        # An absolute path for +word+ against +dir+ with `..` taken
+        # lexically, or nil.
         def resolve(word, dir)
           return nil if word.include?(ShellLex::SUBST) || word == ShellLex::HEREDOC || word.match?(SCRIPT)
 
@@ -137,23 +186,11 @@ module Samagotchi
           dir && File.expand_path(word, dir)
         end
 
-        def expand(word)
-          word = word.sub(%r{\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
+        def expand(word) = PathResolve.expand_word(word, home: @home, env: @env)
       end
+
+      # PathResolve.expand_word, as this module has long named it.
+      def expand_word(word, home:, env:) = PathResolve.expand_word(word, home: home, env: env)
     end
   end
 end