microsandbox-rb 0.5.8 → 0.5.10

data/lib/microsandbox/sandbox.rb

@@ -1,41 +1,119 @@
 # frozen_string_literal: true
 
 module Microsandbox
-  # Lightweight metadata about a sandbox, returned by {Sandbox.get} and
-  # {Sandbox.list}. This is a snapshot, not a live handle.
-  class SandboxInfo
+  # A controllable handle to a sandbox, returned by {Sandbox.get}, {Sandbox.list},
+  # and {Sandbox.list_with}. Carries a metadata snapshot (captured when fetched)
+  # plus the fine-grained lifecycle surface — `stop_with_timeout`, `request_stop`,
+  # `request_kill`, `request_drain`, `wait_until_stopped` — that mirrors the
+  # official SDKs' `SandboxHandle`. (The live {Sandbox} from {Sandbox.create}/
+  # {Sandbox.start} carries only the high-level `stop`/`kill`/`drain`/`wait`.)
+  #
+  # As of v0.5.8 this replaces the old read-only `SandboxInfo` (kept as a
+  # deprecated constant alias); `#status` here is a synchronous snapshot.
+  class SandboxHandle
+    def initialize(native)
+      @native = native
+    end
+
     # @return [String]
-    attr_reader :name
-    # @return [Symbol] :running, :draining, :paused, :stopped, or :crashed
-    attr_reader :status
+    def name = @native.name
 
-    def initialize(data)
-      @name = data["name"]
-      @status = data["status"].to_sym
-      @created_at_ms = data["created_at_ms"]
-      @updated_at_ms = data["updated_at_ms"]
-    end
+    # @return [Symbol] :created, :starting, :running, :draining, :paused,
+    #   :stopped, or :crashed (a snapshot, captured when this handle was fetched)
+    def status = @native.status.to_sym
 
-    def running? = @status == :running
-    def stopped? = @status == :stopped
+    # Whether the fetch-time {#status} snapshot is `:running` / `:stopped`.
+    # Like {#status}, these do NOT refresh: to observe a state change after
+    # {#request_stop}/{#request_kill}/{#request_drain}, use {#wait_until_stopped}
+    # or re-fetch the handle with {Sandbox.get}.
+    def running? = status == :running
+    def stopped? = status == :stopped
 
     # @return [Time, nil]
     def created_at
-      @created_at_ms && Time.at(@created_at_ms / 1000.0)
+      ms = @native.created_at_ms
+      ms && Time.at(ms / 1000.0)
     end
 
     # @return [Time, nil]
     def updated_at
-      @updated_at_ms && Time.at(@updated_at_ms / 1000.0)
+      ms = @native.updated_at_ms
+      ms && Time.at(ms / 1000.0)
+    end
+
+    # Gracefully stop the sandbox (SIGTERM→SIGKILL escalation, 10s default).
+    # @return [nil]
+    def stop
+      @native.stop
+      nil
+    end
+
+    # Gracefully stop with a custom escalation timeout.
+    # @param timeout [Numeric] seconds to wait before escalating to SIGKILL
+    # @return [nil]
+    def stop_with_timeout(timeout)
+      @native.stop_with_timeout(Sandbox.send(:coerce_duration, timeout, "timeout"))
+      nil
+    end
+
+    # Force-kill the sandbox (SIGKILL).
+    # @return [nil]
+    def kill
+      @native.kill
+      nil
+    end
+
+    # Force-kill, waiting up to `timeout` seconds for the process to disappear.
+    # @param timeout [Numeric]
+    # @return [nil]
+    def kill_with_timeout(timeout)
+      @native.kill_with_timeout(Sandbox.send(:coerce_duration, timeout, "timeout"))
+      nil
+    end
+
+    # Send the graceful-shutdown request and return immediately, without waiting.
+    # Pair with {#wait_until_stopped}.
+    # @return [nil]
+    def request_stop
+      @native.request_stop
+      nil
+    end
+
+    # Send the force-kill request and return immediately, without waiting.
+    # @return [nil]
+    def request_kill
+      @native.request_kill
+      nil
+    end
+
+    # Request a graceful drain (SIGUSR1) and return immediately, without waiting.
+    # @return [nil]
+    def request_drain
+      @native.request_drain
+      nil
+    end
+
+    # Block until the sandbox is observed in a terminal (non-running) state.
+    # @return [SandboxStopResult]
+    def wait_until_stopped
+      SandboxStopResult.new(@native.wait_until_stopped)
     end
 
     def inspect
-      "#<Microsandbox::SandboxInfo name=#{@name.inspect} status=#{@status}>"
+      "#<Microsandbox::SandboxHandle name=#{name.inspect} status=#{status}>"
     end
   end
 
+  # @deprecated since v0.5.8. {Sandbox.get}/{Sandbox.list} now return a
+  #   controllable {SandboxHandle}; this constant remains as an alias so code
+  #   that referenced the old read-only metadata type by name (e.g. `is_a?`
+  #   checks) still resolves. Note it is now the same class as {SandboxHandle},
+  #   whose constructor takes a native handle, not the metadata Hash the old
+  #   `SandboxInfo.new` accepted — construct via {Sandbox.get}/{Sandbox.list}.
+  SandboxInfo = SandboxHandle
+
   # The terminal observation of a stopped sandbox, returned by
-  # {Sandbox#wait_until_stopped}. Mirrors the official SDKs' `SandboxStopResult`.
+  # {SandboxHandle#wait_until_stopped}. Mirrors the official SDKs' `SandboxStopResult`.
   class SandboxStopResult
     # @return [String]
     attr_reader :name
@@ -67,7 +145,7 @@ module Microsandbox
 
     def inspect
       "#<Microsandbox::SandboxStopResult name=#{@name.inspect} status=#{@status}" \
-        "#{@exit_code ? " exit_code=#{@exit_code}" : ""}#{@signal ? " signal=#{@signal}" : ""}>"
+        "#{" exit_code=#{@exit_code}" if @exit_code}#{" signal=#{@signal}" if @signal}>"
     end
   end
 
@@ -108,8 +186,15 @@ module Microsandbox
       # @param entrypoint [Array<String>, nil] image entrypoint override
       # @param ports [Hash, nil] host_port => guest_port TCP publications
       # @param ports_udp [Hash, nil] host_port => guest_port UDP publications
-      # @param network ["public_only", "none", "allow_all", "non_local", nil] network
-      #   policy preset (default public_only)
+      # @param network [String, Symbol, NetworkPolicy, Hash, nil] network policy.
+      #   A preset name ("public_only" (default), "none", "allow_all",
+      #   "non_local"), a {NetworkPolicy} (e.g. {NetworkPolicy.custom}), or a Hash
+      #   describing a custom policy (`default_egress:`, `default_ingress:`,
+      #   `rules:`, `deny_domains:`, `deny_domain_suffixes:`). See {NetworkPolicy}
+      #   and {Rule}.
+      # @param patches [Array<Hash>, nil] rootfs patches applied before boot, each
+      #   built with the {Patch} factory (e.g. `Patch.text(...)`, `Patch.mkdir(...)`).
+      #   Not compatible with disk-image roots.
       # @param log_level ["error","warn","info","debug","trace", nil] guest log verbosity
       # @param quiet_logs [Boolean] suppress sandbox process logs
       # @param security ["default", "restricted", nil] exec security profile
@@ -136,14 +221,21 @@ module Microsandbox
       # @yieldparam sandbox [Sandbox]
       # @return [Sandbox, Object] the sandbox, or the block's return value
       def create(name,
-                 image: nil, cpus: nil, memory: nil, env: nil, workdir: nil,
-                 shell: nil, user: nil, hostname: nil, labels: nil, scripts: nil,
-                 entrypoint: nil, ports: nil, ports_udp: nil, volumes: nil, network: nil,
-                 from_snapshot: nil, log_level: nil, quiet_logs: false, security: nil,
-                 oci_upper_size: nil, max_duration: nil, idle_timeout: nil, rlimits: nil,
-                 pull_policy: nil, registry_auth: nil, registry_insecure: false,
-                 registry_ca_certs: nil, secrets: nil,
-                 detached: false, replace: false, replace_with_timeout: nil)
+        image: nil, cpus: nil, memory: nil, env: nil, workdir: nil,
+        shell: nil, user: nil, hostname: nil, labels: nil, scripts: nil,
+        entrypoint: nil, ports: nil, ports_udp: nil, volumes: nil, network: nil,
+        patches: nil,
+        from_snapshot: nil, log_level: nil, quiet_logs: false, security: nil,
+        oci_upper_size: nil, max_duration: nil, idle_timeout: nil, rlimits: nil,
+        pull_policy: nil, registry_auth: nil, registry_insecure: false,
+        registry_ca_certs: nil, secrets: nil,
+        detached: false, replace: false, replace_with_timeout: nil)
+        # A sandbox boots from exactly one rootfs source. The core would reject a
+        # contradictory pair, but only after a runtime round-trip; fail fast and
+        # clearly here (the Python SDK validates this the same way).
+        if image && from_snapshot
+          raise ArgumentError, "provide either image: or from_snapshot:, not both"
+        end
         Microsandbox.ensure_runtime!
         opts = {}
         opts["image"] = image.to_s if image
@@ -161,7 +253,8 @@ module Microsandbox
         opts["ports"] = intify_ports(ports) if ports
         opts["ports_udp"] = intify_ports(ports_udp) if ports_udp
         opts["volumes"] = normalize_volumes(volumes) if volumes
-        opts["network"] = network.to_s if network
+        opts["patches"] = normalize_patches(patches) if patches
+        apply_network_opts(opts, network) unless network.nil?
         opts["log_level"] = log_level.to_s if log_level
         opts["quiet_logs"] = true if quiet_logs
         opts["security"] = security.to_s if security
@@ -174,7 +267,7 @@ module Microsandbox
         opts["secrets"] = normalize_secrets(secrets) if secrets
         opts["detached"] = true if detached
         if replace_with_timeout
-          opts["replace_with_timeout"] = Float(replace_with_timeout)
+          opts["replace_with_timeout"] = coerce_duration(replace_with_timeout, "replace_with_timeout")
         elsif replace
           opts["replace"] = true
         end
@@ -197,27 +290,27 @@ module Microsandbox
       # @return [Sandbox]
       def start(name, detached: false)
         Microsandbox.ensure_runtime!
-        new(Native::Sandbox.start(name.to_s, { "detached" => detached }))
+        new(Native::Sandbox.start(name.to_s, {"detached" => detached}))
       end
 
-      # Fetch metadata for a sandbox by name.
-      # @return [SandboxInfo]
+      # Fetch a controllable handle for a sandbox by name (running or not).
+      # @return [SandboxHandle]
       def get(name)
-        SandboxInfo.new(Native::Sandbox.get(name.to_s))
+        SandboxHandle.new(Native::Sandbox.get(name.to_s))
       end
 
-      # List all sandboxes.
-      # @return [Array<SandboxInfo>]
+      # List all sandboxes as controllable handles.
+      # @return [Array<SandboxHandle>]
       def list
-        Native::Sandbox.list.map { |info| SandboxInfo.new(info) }
+        Native::Sandbox.list.map { |h| SandboxHandle.new(h) }
       end
 
       # List sandboxes carrying all of the given labels (AND-matched).
       # @param labels [Hash] required key => value labels
-      # @return [Array<SandboxInfo>]
+      # @return [Array<SandboxHandle>]
       def list_with(labels: {})
-        opts = { "labels" => stringify(labels) }
-        Native::Sandbox.list_with(opts).map { |info| SandboxInfo.new(info) }
+        opts = {"labels" => stringify(labels)}
+        Native::Sandbox.list_with(opts).map { |h| SandboxHandle.new(h) }
       end
 
       # Remove a (stopped) sandbox by name.
@@ -229,6 +322,19 @@ module Microsandbox
 
       private
 
+      # Coerce a seconds value to a finite, non-negative Float. Rejects negatives,
+      # NaN, and infinities *here* (a clean ArgumentError) rather than letting them
+      # reach the native layer, where `Duration::from_secs_f64` panics across the
+      # FFI boundary on exactly those inputs. Shared by every duration option.
+      def coerce_duration(value, label)
+        seconds = Float(value)
+        unless seconds.finite? && seconds >= 0
+          raise ArgumentError,
+            "#{label} must be a finite, non-negative number of seconds (got #{value.inspect})"
+        end
+        seconds
+      end
+
       def stringify(hash)
         hash.each_with_object({}) { |(k, v), acc| acc[k.to_s] = v.to_s }
       end
@@ -247,7 +353,7 @@ module Microsandbox
           unless username && password
             # Report only the keys given, never the values — auth carries secrets.
             raise ArgumentError,
-                  "registry_auth needs :username and :password (got keys: #{auth.keys.inspect})"
+              "registry_auth needs :username and :password (got keys: #{auth.keys.inspect})"
           end
           opts["registry_username"] = username.to_s
           opts["registry_password"] = password.to_s
@@ -302,6 +408,33 @@ module Microsandbox
           end
         end
       end
+
+      # Normalize a list of patches (each a Hash from the {Patch} factory, or a
+      # plain Hash) into string-keyed Hashes for the native layer. Values are
+      # passed through unchanged (mode stays Integer, content stays String).
+      def normalize_patches(patches)
+        Array(patches).map do |p|
+          unless p.is_a?(Hash)
+            raise ArgumentError, "patch must be a Hash (use Microsandbox::Patch.*): #{p.inspect}"
+          end
+          p.each_with_object({}) { |(k, v), acc| acc[k.to_s] = v }
+        end
+      end
+
+      # Route the `network:` argument to either the preset path
+      # (`opts["network"]`, the original string-preset behavior) or the custom
+      # policy path (`opts["network_policy"]`). Accepts a preset String/Symbol, a
+      # {NetworkPolicy}, or a plain Hash.
+      def apply_network_opts(opts, network)
+        norm = NetworkPolicy.coerce(network)
+        return if norm.empty? # e.g. network: {} — leave the default policy in place
+
+        if norm.keys == ["preset"]
+          opts["network"] = norm["preset"]
+        else
+          opts["network_policy"] = norm
+        end
+      end
     end
 
     def initialize(native)
@@ -322,33 +455,78 @@ module Microsandbox
     # @param env [Hash, nil] extra environment variables
     # @param timeout [Numeric, nil] kill after N seconds
     # @param tty [Boolean] allocate a pseudo-terminal
-    # @param stdin [String, nil] data to feed to stdin
+    # @param stdin [String, Symbol, nil] bytes to feed to stdin, or +:pipe+ to
+    #   open a streaming stdin pipe (write/close it via {ExecHandle#stdin}; only
+    #   useful with the streaming variants)
     # @return [ExecOutput]
     def exec(command, args = [], cwd: nil, user: nil, env: nil, timeout: nil, tty: false, stdin: nil, rlimits: nil)
       ExecOutput.new(@native.exec(command.to_s, Array(args).map(&:to_s),
-                                  exec_opts(cwd:, user:, env:, timeout:, tty:, stdin:, rlimits:)))
+        exec_opts(cwd:, user:, env:, timeout:, tty:, stdin:, rlimits:)))
     end
 
     # Run a shell script (pipes, redirects, etc. allowed) and collect output.
     # @return [ExecOutput]
     def shell(script, cwd: nil, user: nil, env: nil, timeout: nil, tty: false, stdin: nil, rlimits: nil)
       ExecOutput.new(@native.shell(script.to_s,
-                                   exec_opts(cwd:, user:, env:, timeout:, tty:, stdin:, rlimits:)))
+        exec_opts(cwd:, user:, env:, timeout:, tty:, stdin:, rlimits:)))
     end
 
     # Run a command and stream its output as it arrives.
+    #
+    # Pass +stdin: :pipe+ to feed the process interactively: {ExecHandle#stdin}
+    # then returns a writable sink; close it to send EOF (a process like +cat+
+    # that reads until EOF will otherwise block forever).
     # @return [ExecHandle]
     # @see ExecHandle
     def exec_stream(command, args = [], cwd: nil, user: nil, env: nil, timeout: nil, tty: false, stdin: nil, rlimits: nil)
       ExecHandle.new(@native.exec_stream(command.to_s, Array(args).map(&:to_s),
-                                         exec_opts(cwd:, user:, env:, timeout:, tty:, stdin:, rlimits:)))
+        exec_opts(cwd:, user:, env:, timeout:, tty:, stdin:, rlimits:, pipe_ok: true)))
     end
 
     # Run a shell script and stream its output as it arrives.
     # @return [ExecHandle]
     def shell_stream(script, cwd: nil, user: nil, env: nil, timeout: nil, tty: false, stdin: nil, rlimits: nil)
       ExecHandle.new(@native.shell_stream(script.to_s,
-                                          exec_opts(cwd:, user:, env:, timeout:, tty:, stdin:, rlimits:)))
+        exec_opts(cwd:, user:, env:, timeout:, tty:, stdin:, rlimits:, pipe_ok: true)))
+    end
+
+    # Attach an interactive terminal to a command in the sandbox.
+    #
+    # Puts the **host** terminal into raw mode and forwards keystrokes (and
+    # SIGWINCH resizes) to the guest until the command exits or the detach
+    # sequence is typed. Requires a real TTY on stdin/stdout, so it is for CLI
+    # use, not library/automation code (use {#exec}/{#exec_stream} there). Blocks
+    # until the session ends. Mirrors the official SDKs' `attach`.
+    #
+    # @param command [String] the program to run
+    # @param args [Array<String>] its arguments
+    # @param cwd [String, nil] working directory
+    # @param user [String, nil] user to run as
+    # @param env [Hash, nil] extra environment variables
+    # @param detach_keys [String, nil] detach sequence (e.g. "ctrl-p,ctrl-q";
+    #   default "ctrl-]")
+    # @param rlimits [Hash, nil] resource limits (see {#exec})
+    # @return [Integer] the command's exit code (or the code at detach)
+    def attach(command, args = [], cwd: nil, user: nil, env: nil, detach_keys: nil, rlimits: nil)
+      opts = {}
+      opts["cwd"] = cwd.to_s if cwd
+      opts["user"] = user.to_s if user
+      opts["env"] = env.each_with_object({}) { |(k, v), a| a[k.to_s] = v.to_s } if env
+      opts["detach_keys"] = detach_keys.to_s if detach_keys
+      if rlimits
+        opts["rlimits"] = rlimits.map do |resource, limit|
+          soft, hard = limit.is_a?(Array) ? [limit[0], limit[1]] : [limit, limit]
+          [resource.to_s, Integer(soft), Integer(hard)]
+        end
+      end
+      @native.attach(command.to_s, Array(args).map(&:to_s), opts)
+    end
+
+    # Attach an interactive terminal running the sandbox's default shell.
+    # See {#attach} for the host-TTY requirements.
+    # @return [Integer] the shell's exit code (or the code at detach)
+    def attach_shell
+      @native.attach_shell
     end
 
     # Guest filesystem operations.
@@ -357,6 +535,15 @@ module Microsandbox
       @fs ||= FS.new(@native)
     end
 
+    # SSH access to the sandbox — open a native in-process SSH client or prepare
+    # a reusable server endpoint.
+    # @return [SshOps]
+    # @example
+    #   sb.ssh.open_client { |c| puts c.exec("hostname").stdout }
+    def ssh
+      SshOps.new(@native)
+    end
+
     # Latest resource-usage snapshot.
     # @return [Metrics]
     def metrics
@@ -385,7 +572,7 @@ module Microsandbox
     # @param interval [Numeric] seconds between snapshots
     # @return [MetricsStream] an {Enumerable} of {Metrics}
     def metrics_stream(interval: 1.0)
-      MetricsStream.new(@native.metrics_stream(Float(interval)))
+      MetricsStream.new(@native.metrics_stream(coerce_duration(interval, "interval")))
     end
 
     # Stream captured logs as they appear.
@@ -408,48 +595,46 @@ module Microsandbox
       LogStream.new(@native.log_stream(opts))
     end
 
-    # Gracefully stop the sandbox (and wait for it to terminate).
-    # @param timeout [Numeric, nil] seconds to wait before SIGKILL
+    # Gracefully stop the sandbox (SIGTERM→SIGKILL escalation, 10s default) and
+    # wait for it to terminate. For a custom timeout or fire-and-return
+    # `request_*` control, fetch a {SandboxHandle} via {Sandbox.get}.
     # @return [nil]
-    def stop(timeout: nil)
-      @native.stop(timeout && Float(timeout))
+    def stop
+      @native.stop
       nil
     end
 
-    # Force-kill the sandbox (SIGKILL).
-    # @param timeout [Numeric, nil] seconds to wait
-    # @return [nil]
-    def kill(timeout: nil)
-      @native.kill(timeout && Float(timeout))
-      nil
+    # Gracefully stop, then wait for the process to exit.
+    # @return [ExitStatus]
+    def stop_and_wait
+      ExitStatus.new(@native.stop_and_wait)
     end
 
-    # Send the graceful-shutdown request and return immediately, without waiting
-    # for the sandbox to terminate. Pair with {#wait_until_stopped}.
+    # Force-kill the sandbox (SIGKILL).
     # @return [nil]
-    def request_stop
-      @native.request_stop
+    def kill
+      @native.kill
       nil
     end
 
-    # Send the force-kill request and return immediately, without waiting.
+    # Trigger a graceful drain (SIGUSR1).
     # @return [nil]
-    def request_kill
-      @native.request_kill
+    def drain
+      @native.drain
       nil
     end
 
-    # Request a graceful drain and return immediately, without waiting.
-    # @return [nil]
-    def request_drain
-      @native.request_drain
-      nil
+    # Wait for the sandbox process to exit.
+    # @return [ExitStatus]
+    def wait
+      ExitStatus.new(@native.wait)
     end
 
-    # Block until the sandbox is observed in a terminal (non-running) state.
-    # @return [SandboxStopResult]
-    def wait_until_stopped
-      SandboxStopResult.new(@native.wait_until_stopped)
+    # The live status, fetched from the backend (a round-trip per call).
+    # @return [Symbol] :created, :starting, :running, :draining, :paused,
+    #   :stopped, or :crashed
+    def status
+      @native.status.to_sym
     end
 
     # @return [Boolean] whether this handle owns the sandbox process lifecycle
@@ -472,14 +657,37 @@ module Microsandbox
 
     private
 
-    def exec_opts(cwd:, user:, env:, timeout:, tty:, stdin:, rlimits:)
+    # Instance-side shim for the shared, class-private duration validator (used
+    # by #exec/#shell timeouts, #stop/#kill, and #metrics_stream).
+    def coerce_duration(value, label)
+      self.class.send(:coerce_duration, value, label)
+    end
+
+    def exec_opts(cwd:, user:, env:, timeout:, tty:, stdin:, rlimits:, pipe_ok: false)
       opts = {}
       opts["cwd"] = cwd.to_s if cwd
       opts["user"] = user.to_s if user
       opts["env"] = env.each_with_object({}) { |(k, v), a| a[k.to_s] = v.to_s } if env
-      opts["timeout"] = Float(timeout) if timeout
+      opts["timeout"] = coerce_duration(timeout, "timeout") if timeout
       opts["tty"] = true if tty
-      opts["stdin"] = stdin.to_s if stdin
+      # `stdin: :pipe` opens a streaming stdin pipe — write to it via
+      # {ExecHandle#stdin} and close to send EOF. It is only meaningful for the
+      # streaming variants (which return an ExecHandle); a blocking exec/shell
+      # collects to completion and has nowhere to hand back the sink, so a piped
+      # process that reads stdin would block forever waiting for EOF. Reject it
+      # there. Any other truthy value is fed as a fixed byte buffer (closed
+      # automatically). nil means no stdin.
+      case stdin
+      when nil then nil
+      when :pipe
+        unless pipe_ok
+          raise ArgumentError,
+            "stdin: :pipe is only valid for exec_stream/shell_stream — a blocking " \
+            "exec/shell cannot expose a writable stdin sink; pass a String to feed bytes"
+        end
+        opts["stdin_pipe"] = true
+      else opts["stdin"] = stdin.to_s
+      end
       if rlimits
         opts["rlimits"] = rlimits.map do |resource, limit|
           soft, hard = limit.is_a?(Array) ? [limit[0], limit[1]] : [limit, limit]

data/lib/microsandbox/snapshot.rb

@@ -43,7 +43,7 @@ module Microsandbox
     end
 
     def inspect
-      "#<Microsandbox::SnapshotInfo digest=#{@digest.inspect}#{@name ? " name=#{@name.inspect}" : ""}>"
+      "#<Microsandbox::SnapshotInfo digest=#{@digest.inspect}#{" name=#{@name.inspect}" if @name}>"
     end
   end
 
@@ -142,7 +142,7 @@ module Microsandbox
       # @param dest [String, nil] explicit destination directory
       # @return [SnapshotInfo]
       def import(archive_path, dest: nil)
-        SnapshotInfo.new(Native::Snapshot.import(archive_path.to_s, dest && dest.to_s))
+        SnapshotInfo.new(Native::Snapshot.import(archive_path.to_s, dest&.to_s))
       end
 
       private