maf 0.1.0 → 0.3.0

data/lib/maf/shared/harnesses/hermes.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+# maf shared library - code that the maf CLI and the scripts in .maf/bin share.
+# The installer copies this folder to .maf/lib/maf/shared/. maf update replaces it.
+# Use the Ruby stdlib only: a script loads this file without a gem bundle.
+require_relative "../harness/traits"
+require_relative "../roles"
+
+module Maf
+  module Shared
+    module Harnesses
+      # Hermes loads role files as skills from <hermes_dir>/<project>-<role>/,
+      # outside the project. `--skills <project>-<role>` loads one. Hermes has
+      # no agent flag and cannot be woken, so an idle agent blocks in
+      # `coord next --wait`. A role with can_edit false starts without the
+      # file-writing toolsets. No role gets the kanban or delegation
+      # toolset. Hermes keeps hooks and MCP servers in global
+      # files, so maf prints the commands that add them.
+      class Hermes < Harness::Base
+        include Harness::ResultEvent
+
+        DEFAULT_DIR = File.join(Dir.home, ".hermes", "skills")
+        MAX_TURNS = 50
+
+        def sandbox_dirs = [File.join(Dir.home, ".hermes")]
+        PROTECTED = %w[config.yaml .env shell_init.sh SOUL.md hooks agent-hooks shell-hooks-allowlist.json bin scripts
+                       cron skills plugins hermes-agent].freeze
+        def sandbox_protected = in_dir(File.join(Dir.home, ".hermes"), PROTECTED)
+        STATE = %w[sessions logs cache memories state *.db* pastes composer-pastes image_cache audio_cache locks
+                   pending runtime telemetry terminal-sessions processes.json* spawn-ledger.json* auth.json* auth.lock
+                   google_token.json* models_dev_cache* provider_models_cache.json* context_length_cache.yaml*
+                   .hermes_history* .*lock*].freeze
+        def sandbox_state = in_dir(File.join(Dir.home, ".hermes"), STATE)
+        def sandbox_placeholders = super - [File.join(Dir.home, ".hermes", "hermes-agent")]
+        def vm_credentials = [Harness::VmCredential.file(File.join(Dir.home, ".hermes", ".env"), ".hermes/.env")]
+
+        def role_destination(project, role, settings = {})
+          File.join(settings["hermes_dir"] || DEFAULT_DIR, "#{File.basename(project)}-#{role}", "SKILL.md")
+        end
+
+        def role_template = <<~ERB
+          ---
+          # >>> multi-agent-flow >>>
+          name: <%= role %>
+          description: <%= description %>
+          ---
+
+          # <%= title %>
+
+          <% if model -%>
+          > Model: `<%= model %>` (Hermes sets the model with `hermes model`)
+          <% end -%>
+          <%= prompt %>
+        ERB
+
+        def model_hint(_model) = "hermes model"
+        EFFORTS = %w[none minimal low medium high xhigh max ultra].freeze
+        def efforts(_model = nil) = EFFORTS
+        def effort_flag(effort) = super(effort, "--reasoning")
+        def mcp_command(server, vault) = "hermes mcp add #{server} --command ruby --args #{vault} mcp"
+        def install_hooks(_project) = Flow::HermesHookSetup.new.install | Flow::HermesEnvSetup.new.install
+        def global_files = [File.join(Dir.home, ".hermes", "agent-hooks", "next-task.sh")]
+
+        # The skill name uses the main checkout's name, from the project root
+        # and from a worktree alike.
+        def skill_name(role) = "#{File.basename(Project.root)}-#{role}"
+
+        # The skill that maf add generated for the role, or nil.
+        def skill(role)
+          dir = Project.manifest.fetch("hermes_dir", DEFAULT_DIR)
+          File.exist?(File.join(dir, skill_name(role), "SKILL.md")) ? skill_name(role) : nil
+        end
+
+        def read_only?(role)
+          Project.manifest.fetch("agents", []).any? { |agent| agent["role"] == role && agent["can_edit"] == false }
+        end
+
+        # With -t, Hermes loads an MCP server only when the list names its toolset.
+        def tools(role)
+          toolsets = read_only?(role) ? Roles::READ_ONLY_TOOLSETS : Roles::EDIT_TOOLSETS
+          ["-t", "#{toolsets},mcp-graphify-#{File.basename(Project.root)}"]
+        end
+
+        PROMPT = "Follow the coordination rules of your role skill as role %<role>s. " \
+                 "Run coord inbox, then coord next --wait. Claim a task, do the work, finish it. Repeat."
+        LEAD_PROMPT = "Follow your role skill and its coordination rules as role %<role>s. " \
+                      "You are a lead role. Never claim a task. Run coord inbox --wait and handle each message."
+
+        # `-q` on a TTY seeds an interactive session with the prompt.
+        def launch(role, model, effort = nil)
+          prompt = format(Roles::LEADS.include?(role) ? LEAD_PROMPT : PROMPT, role: role)
+          ["hermes", "chat", *skill(role)&.then { |name| ["--skills", name] }, *model_flag(model), *effort_flag(effort),
+           *tools(role), "-q", prompt]
+        end
+
+        # --no-skill drops the skill. Without --skill, the generated skill of the role loads.
+        def prepare(config)
+          config.skill = nil if config.no_skill
+          config.skill ||= skill(config.role) unless config.no_skill
+          config.max_turns ||= MAX_TURNS
+          config
+        end
+
+        # `hermes chat --oneshot` with JSONL output and the skill preloaded.
+        def build_command(config, prompt, session_id)
+          cmd = %w[hermes chat --oneshot --yolo --format stream-json -Q]
+          cmd += run_flags(config)
+          cmd += ["--max-turns", config.max_turns.to_s]
+          cmd + resume(session_id, "--resume") + ["-q", prompt]
+        end
+
+        def run_flags(config)
+          [*(["--skills", config.skill] if config.skill), *model_flag(config.model), *effort_flag(config.effort),
+           *tools(config.role)]
+        end
+
+        def stale_session?(output) = output.include?("Session not found")
+        def result_text(output) = result_event(output)["text"]
+      end
+    end
+  end
+end

data/lib/maf/shared/harnesses/opencode.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+# maf shared library - code that the maf CLI and the scripts in .maf/bin share.
+# The installer copies this folder to .maf/lib/maf/shared/. maf update replaces it.
+# Use the Ruby stdlib only: a script loads this file without a gem bundle.
+require "open3"
+require_relative "../harness/traits"
+
+module Maf
+  module Shared
+    module Harnesses
+      # OpencodeSandbox holds the sandbox paths of opencode.
+      module OpencodeSandbox
+        DATA_DIRS = %w[.local/share/opencode .local/state/opencode .config/opencode].freeze
+        def sandbox_dirs = DATA_DIRS.map { |dir| File.join(Dir.home, dir) }
+        PROTECTED = %w[opencode.json opencode.jsonc config.json package.json node_modules plugin plugins agent agents
+                       command commands skills AGENTS.md].freeze
+        def sandbox_protected = in_dir(sandbox_dirs.last, PROTECTED)
+        STATE = %w[auth.json* log opencode.db* repos snapshot tool-output storage project].freeze
+        def sandbox_state = [*in_dir(sandbox_dirs.first, STATE), File.join(sandbox_dirs[1], "*")]
+        def sandbox_project = %w[opencode.json opencode.jsonc .opencode]
+      end
+
+      # opencode. `--agent` loads .opencode/agents/<role>.md. The board-watch
+      # plugin in .opencode/plugins/ wakes an idle session. opencode merges the
+      # file in OPENCODE_CONFIG with the project's opencode.json.
+      class Opencode < Harness::Base
+        include OpencodeSandbox
+
+        def role_dir = ".opencode/agents"
+
+        def role_template = <<~ERB
+          ---
+          # >>> multi-agent-flow >>>
+          description: <%= description %>
+          mode: all
+          <% if model -%>
+          model: <%= model %>
+          <% end -%>
+          <% if effort -%>
+          variant: <%= effort %>
+          <% end -%>
+          temperature: 0.1
+          permission:
+            edit: <%= can_edit ? "allow" : "deny" %>
+            bash: allow
+            # Worktrees live inside the project. The board, the artifacts, and git
+            # data are outside the worktree, so opencode would ask for each access.
+            external_directory:
+              "/tmp/*": allow
+              "/private/tmp/*": allow
+              "<%= project %>/.maf/*": allow
+              "<%= project %>/.git/*": allow
+            task:
+              "*": deny
+              explore: allow
+          ---
+
+          <%= prompt %>
+        ERB
+
+        def models
+          return nil unless installed?
+
+          out, status = Open3.capture2("opencode", "models", err: File::NULL)
+          status.success? && !out.strip.empty? ? out.split : nil
+        rescue SystemCallError
+          nil
+        end
+
+        def wait = :watch
+
+        def vm_install = "curl -fsSL https://opencode.ai/install | bash"
+        AUTH = ".local/share/opencode/auth.json"
+        def vm_credentials = [Harness::VmCredential.file(File.join(Dir.home, AUTH), AUTH)]
+
+        def mcp
+          { file: ".maf/mcp/opencode.json", key: "mcp", schema: "https://opencode.ai/config.json",
+            entry: { "type" => "local", "command" => Harness::VAULT_MCP, "enabled" => true } }
+        end
+
+        def legacy_mcp_file = "opencode.json"
+        def bootstrap_dir = ".opencode"
+
+        PLUGIN = ".opencode/plugins/board-watch.js"
+
+        def runtime_hooks(worktree) = SetupAgent::RuntimeHooks.copy(worktree, "board-watch-opencode.js", PLUGIN)
+        def runtime_files = [PLUGIN]
+        def empty_dirs = [role_dir, File.dirname(PLUGIN), home_dir]
+
+        # An older maf tracked the role files and the plugin.
+        def untrack_paths(_root, tracked) = tracked.call(role_dir) + tracked.call(PLUGIN)
+
+        def launch_env = config_env(flow_file("mcp", "opencode.json"))
+        def run_env(config) = config_env(run_file(config, "mcp", "opencode.json"))
+        def config_env(file) = File.exist?(file) ? { "OPENCODE_CONFIG" => file } : {}
+
+        # The TUI has no variant flag. It reads the variant from the agent file.
+        def launch(role, model, effort = nil)
+          OpencodeVariant.warn_unused(File.join(role_dir, "#{role}.md"), role, effort)
+          ["opencode", ".", "--agent", role, "--prompt", "Start your work loop now.", *model_flag(model)]
+        end
+
+        def effort_flag(effort) = super(effort, "--variant")
+
+        # `opencode run --format json`. The result event shape is not verified,
+        # so the log shows no result text.
+        def build_command(config, prompt, session_id)
+          %w[opencode run --format json --agent] + [config.role] + model_flag(config.model, "-m") +
+            effort_flag(config.effort) + resume(session_id, "--session") + [prompt]
+        end
+
+        # DeepSeek costs twice as much at peak hours.
+        def peak_rate?(config) = configured_model(config).to_s.include?("deepseek")
+
+        # The model of a run in the opencode order: --model, the agent file, the project config, the user config.
+        CONFIG_MODEL = /^\s*"model"\s*:\s*"([^"]+)"/
+        AGENT_MODEL = /\A---\n(?:(?!^---$).)*?^model:\s*(\S+)/m
+
+        def configured_model(config)
+          config.model || find(File.join(role_dir, "#{config.role}.md"), AGENT_MODEL) ||
+            config_paths.lazy.filter_map { |path| find(path, CONFIG_MODEL) }.first
+        end
+
+        def config_paths
+          home = File.join(ENV.fetch("XDG_CONFIG_HOME", File.join(Dir.home, ".config")), "opencode")
+          %w[opencode.json opencode.jsonc] + %w[opencode.jsonc opencode.json].map { |name| File.join(home, name) }
+        end
+
+        def find(path, pattern) = File.exist?(path) ? File.read(path)[pattern, 1] : nil
+
+        # opencode prints terminal escape codes and can glue two JSON objects
+        # onto one line, so the session ID is matched on the start of an event
+        # object (captured from a real run), not by parsing whole lines.
+        EVENT_SESSION = /\{"type":"[\w.-]+","timestamp":\d+,"sessionID":"([^"]+)"/
+        # Each model call ends with a step_finish event. Its tokens.input
+        # excludes the cache reads and writes; reasoning is billed as output.
+        STEP_FINISH = /\{"type":"step_finish".*/
+
+        def stale_session?(output) = output.include?("Session not found")
+        def session_id(output) = output.scan(EVENT_SESSION).flatten.last
+
+        def steps(output)
+          output.scan(STEP_FINISH).filter_map { |json| Harness::Events.parse(json)&.dig("part", "tokens") }
+        end
+
+        def usage(output) = Harness::Usage.sum(steps(output).map { |tokens| Harness::Usage.normalize(flat(tokens)) })
+        def context(output) = steps(output).last&.then { |tokens| Harness::Usage.input(flat(tokens)) }
+
+        def flat(tokens)
+          { "input_tokens" => tokens["input"].to_i, "cache_read_input_tokens" => tokens.dig("cache", "read").to_i,
+            "cache_creation_input_tokens" => tokens.dig("cache", "write").to_i,
+            "output_tokens" => tokens["output"].to_i + tokens["reasoning"].to_i }
+        end
+
+        # opencode keeps its sessions in a SQLite database. The sqlite3 CLI reads it.
+        def database = File.join(Dir.home, ".local", "share", "opencode", "opencode.db")
+
+        def transcript_calls(id)
+          return [] unless File.exist?(database) && id.match?(/\A[\w-]+\z/)
+
+          out, status = Open3.capture2("sqlite3", "-readonly", "-json", database, transcript_query(id))
+          status.success? && !out.empty? ? JSON.parse(out).map(&:values) : []
+        rescue SystemCallError, JSON::ParserError
+          []
+        end
+
+        def transcript_query(id)
+          "select json_extract(data,'$.tool') tool, json_extract(data,'$.state.input.command') command, " \
+            "length(json_extract(data,'$.state.output')) size from part where session_id = '#{id}' " \
+            "and json_extract(data,'$.type') = 'tool'"
+        end
+      end
+
+      # OpencodeVariant tells the user how to change the level of an interactive session.
+      module OpencodeVariant
+        PATTERN = /\A---\n(?:(?!^---$).)*?^variant:\s*(\S+)/m
+        HINT = "maf: the opencode TUI cannot take --effort %<effort>s. The session starts with %<current>s. " \
+               "In the session, press ctrl+t to pick the variant %<effort>s. If the agent is in its work " \
+               "loop, stop it (Esc) and restart the loop: \"Start your work loop now.\" " \
+               "To keep the level for each session: maf add opencode:%<role>s --effort %<role>s=%<effort>s"
+
+        def self.warn_unused(path, role, effort)
+          current = File.exist?(path) ? File.read(path)[PATTERN, 1] : nil
+          return if effort.nil? || effort == current
+
+          warn format(HINT, effort: effort, role: role, current: current ? "variant #{current}" : "the default variant")
+        end
+      end
+    end
+  end
+end

data/lib/maf/shared/processes.rb

@@ -3,6 +3,7 @@
 # maf shared library - code that the maf CLI and the scripts in .maf/bin share.
 # The installer copies this folder to .maf/lib/maf/shared/. maf update replaces it.
 # Use the Ruby stdlib only: a script loads this file without a gem bundle.
+require "time"
 
 module Maf
   module Shared
@@ -20,6 +21,25 @@ module Maf
         true
       end
 
+      def self.same?(pid, started)
+        !started.to_s.empty? && alive?(pid) && started_at(pid) == started.to_s
+      end
+
+      LEGACY_LIVE_WINDOW = 3600
+
+      def self.live?(entry)
+        return false unless alive?(entry["pid"])
+
+        recorded = entry["started"].to_s
+        recorded.empty? ? recent?(entry["seen_at"]) : recorded == started_at(entry["pid"])
+      end
+
+      def self.recent?(seen_at)
+        Time.now - Time.parse(seen_at.to_s) < LEGACY_LIVE_WINDOW
+      rescue ArgumentError
+        false
+      end
+
       # The start time as ps prints it, or "" when ps fails.
       def self.started_at(pid)
         IO.popen(PS_ENV, ["ps", "-o", "lstart=", "-p", pid.to_s], err: File::NULL, &:read).to_s.strip

data/lib/maf/shared/roles.rb

@@ -14,6 +14,10 @@ module Maf
       # Hermes toolsets for a role with can_edit false: no file, code_execution,
       # or delegation toolset. The shell stays, because the role needs coord and git.
       READ_ONLY_TOOLSETS = "terminal,web,skills,todo,memory,session_search,clarify"
+
+      # Hermes toolsets for a role that edits. coord is the only task board and
+      # maf starts the workers, so kanban, delegation, and cronjob stay off.
+      EDIT_TOOLSETS = "#{READ_ONLY_TOOLSETS},file,code_execution,browser,vision".freeze
     end
   end
 end

data/lib/maf/shared/sandbox/bwrap.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+# maf shared library - code that the maf CLI and the scripts in .maf/bin share.
+# The installer copies this folder to .maf/lib/maf/shared/. maf update replaces it.
+# Use the Ruby stdlib only: a script loads this file without a gem bundle.
+require "fileutils"
+
+module Maf
+  module Shared
+    module Sandbox
+      # Bwrap runs a command in a Linux bubblewrap sandbox.
+      module Bwrap
+        COMMAND = "bwrap"
+        MARKER = "MAF_BWRAP"
+        BASE = ["--ro-bind", "/", "/", "--dev-bind", "/dev", "/dev", "--tmpfs", "/dev/shm", "--proc", "/proc",
+                "--tmpfs", "/tmp", "--setenv", MARKER, "1"].freeze
+        MASKED_DIRS = %w[/run/user /run/dbus].freeze
+        MASKED_SOCKETS = %w[/run/docker.sock /run/podman/podman.sock /run/containerd/containerd.sock].freeze
+        HOOK = "# Project hook for coord worktree. See assets/worktree-env.example.rb in the maf gem.\n"
+
+        def self.wrap(cmd, paths)
+          return cmd if inside?
+
+          [binary, *BASE, *masks, *home, *binds(paths), *protects(paths), "--die-with-parent", "--", *cmd]
+        end
+
+        def self.available? = !binary.nil?
+
+        def self.binary
+          dirs = ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).reject { |dir| agent_dir?(File.expand_path(dir)) }
+          dirs.map { |dir| File.join(dir, COMMAND) }.find { |file| File.executable?(file) }
+        end
+
+        def self.agent_dir?(dir)
+          writes = Array(Sandbox.policy["write"]).map { |path| File.expand_path(path, Project.root) }
+          tops = [Project.root, "/tmp", "/var/tmp", ENV.fetch("TMPDIR", nil), *writes].compact.map { _1.chomp("/") }
+          tops.any? { |top| dir == top || dir.start_with?("#{top}/") }
+        end
+
+        def self.require!
+          inside? || (available? && overlay?) || abort("maf: sandbox mode bwrap needs bubblewrap 0.10 or later.")
+        end
+
+        def self.inside?(mountinfo = "/proc/self/mountinfo")
+          ENV[MARKER] == "1" && File.foreach(mountinfo).any? { |line| home_overlay?(line) }
+        rescue SystemCallError
+          false
+        end
+
+        # mountinfo writes a space in a path as \040.
+        def self.home_overlay?(line) = line.include?(" #{mount_path(Dir.home)} ") && line.include?(" - overlay ")
+        def self.mount_path(path) = path.gsub(" ", "\\\\040")
+
+        def self.masks
+          runtime = ENV.fetch("XDG_RUNTIME_DIR", "")
+          MASKED_DIRS.select { |dir| File.directory?(dir) }.flat_map { |dir| ["--tmpfs", dir] } +
+            (runtime.start_with?("/run/user/") ? ["--dir", runtime] : []) +
+            MASKED_SOCKETS.select { |path| File.exist?(path) }.flat_map { |path| ["--ro-bind", "/dev/null", path] }
+        end
+
+        def self.home = ["--overlay-src", Dir.home, "--tmp-overlay", Dir.home]
+        def self.overlay? = IO.popen([binary, "--help"], err: %i[child out], &:read).include?("--tmp-overlay")
+
+        def self.binds(paths)
+          FileUtils.mkdir_p(paths.harness_dirs)
+          paths.prefixes.each { |file| File.exist?(file) || File.write(file, "{}\n") }
+          writable(paths).select { |path| File.exist?(path) }.flat_map { |path| ["--bind", path, path] }
+        end
+
+        def self.writable(paths)
+          ((paths.dirs - ["/tmp"]) + paths.harness_dirs + paths.prefixes).reject { |path| masked?(path) }
+        end
+
+        def self.masked?(path)
+          (MASKED_DIRS + MASKED_SOCKETS).any? do |mask|
+            path == mask || path.start_with?("#{mask}/") || mask.start_with?("#{path.chomp("/")}/")
+          end
+        end
+
+        # A mount point cannot be renamed, so each parent folder is bound onto itself.
+        # Then each protected path is bound read-only.
+        def self.protects(paths)
+          create_protected(paths)
+          parents = bound_parents(paths).select { |dir| File.directory?(dir) }.flat_map { |dir| ["--bind", dir, dir] }
+          parents + paths.protected.select { |path| File.exist?(path) }.flat_map { |path| ["--ro-bind", path, path] }
+        end
+
+        def self.bound_parents(paths)
+          tops = writable(paths)
+          paths.parents.select { |dir| tops.any? { |top| dir == top || dir.start_with?("#{top.chomp("/")}/") } }
+        end
+
+        # A bind needs an existing path. Else the agent could create a protected
+        # path, so the folders, the worktree hook, and the harness config are created first.
+        def self.create_protected(paths)
+          paths.protected_dirs.each { |dir| make(dir) }
+          create_hook(paths.coord_file("worktree-env.rb"))
+          paths.placeholders.each { |path| placeholder(path) }
+        end
+
+        def self.create_hook(hook)
+          File.exist?(File.dirname(hook)) && !File.exist?(hook) && File.write(hook, HOOK)
+        end
+
+        def self.placeholder(path)
+          return if File.exist?(path) || File.symlink?(path) || !File.directory?(File.dirname(path))
+
+          name = File.basename(path)
+          File.extname(name).empty? && !name.start_with?(".") ? make(path) : write(path, empty_text(name))
+        end
+
+        def self.write(path, text)
+          File.write(path, text)
+        rescue SystemCallError
+          nil
+        end
+
+        def self.empty_text(name) = name.end_with?(".json", ".jsonc") ? "{}\n" : ""
+
+        def self.make(dir)
+          FileUtils.mkdir_p(dir)
+        rescue SystemCallError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/maf/shared/sandbox/harness_files.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# maf shared library - code that the maf CLI and the scripts in .maf/bin share.
+# The installer copies this folder to .maf/lib/maf/shared/. maf update replaces it.
+# Use the Ruby stdlib only: a script loads this file without a gem bundle.
+
+module Maf
+  module Shared
+    module Sandbox
+      # HarnessFiles holds the state paths and the protected paths in the folders of the harnesses.
+      class HarnessFiles
+        def initialize(harnesses, real)
+          @harnesses = harnesses
+          @real = real
+        end
+
+        def dirs = @dirs ||= @real.call(@harnesses.flat_map(&:sandbox_dirs))
+        def prefixes = @real.call(@harnesses.flat_map(&:sandbox_prefixes))
+        def placeholders = @harnesses.flat_map(&:sandbox_placeholders)
+        def config = @harnesses.flat_map(&:sandbox_protected).select { |path| File.file?(path) }
+
+        def state
+          @state ||= @harnesses.flat_map(&:sandbox_state).map do |pattern|
+            pattern = File.expand_path(pattern)
+            File.join(@real.call([File.dirname(pattern)]).first, File.basename(pattern))
+          end
+        end
+
+        def state?(path)
+          dir = dirs.find { |folder| path.start_with?("#{folder}/") } or return false
+          top = File.join(dir, path.delete_prefix("#{dir}/").split("/").first)
+          state.any? { |pattern| File.fnmatch?(pattern, top, File::FNM_DOTMATCH | File::FNM_PATHNAME) }
+        end
+
+        def locked
+          @locked ||= (dirs.flat_map { |dir| children(dir) }.reject { |path| state?(path) } +
+                       @harnesses.flat_map(&:sandbox_protected)).uniq
+        end
+
+        private
+
+        def children(dir)
+          Dir.children(dir).map { |name| File.join(dir, name) }
+        rescue SystemCallError
+          []
+        end
+      end
+    end
+  end
+end

data/lib/maf/shared/sandbox/links.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# maf shared library - code that the maf CLI and the scripts in .maf/bin share.
+# The installer copies this folder to .maf/lib/maf/shared/. maf update replaces it.
+# Use the Ruby stdlib only: a script loads this file without a gem bundle.
+require "fileutils"
+
+module Maf
+  module Shared
+    module Sandbox
+      # Links puts back a protected symlink that the agent changed in a bwrap run.
+      module Links
+        def self.record(paths) = paths.select { |path| File.symlink?(path) }.to_h { |path| [path, File.readlink(path)] }
+
+        def self.restore(links) = links.each { |link, target| restore_link(link, target) }
+
+        def self.restore_link(link, target)
+          return if File.symlink?(link) && File.readlink(link) == target
+
+          warn "maf: sandbox: the agent changed the protected link #{link}. maf put it back."
+          FileUtils.rm_rf(link) && File.symlink(target, link)
+        rescue SystemCallError => e
+          warn "maf: sandbox: cannot put back the link #{link}: #{e.message}"
+        end
+      end
+    end
+  end
+end