microsandbox-rb 0.5.8 → 0.5.10

data/lib/microsandbox/ssh.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+module Microsandbox
+  # The result of an {SshClient#exec} call. Like {ExecOutput}, `stdout`/`stderr`
+  # are the captured bytes decoded as UTF-8 (lenient); use `stdout_bytes`/
+  # `stderr_bytes` for the raw ASCII-8BIT bytes.
+  class SshOutput
+    # @return [Integer] the remote command's exit status
+    attr_reader :status
+    # @return [String] raw stdout bytes (ASCII-8BIT)
+    attr_reader :stdout_bytes
+    # @return [String] raw stderr bytes (ASCII-8BIT)
+    attr_reader :stderr_bytes
+
+    def initialize(data)
+      @status = data["status"]
+      @success = data["success"]
+      @stdout_bytes = data["stdout"]
+      @stderr_bytes = data["stderr"]
+    end
+
+    # @return [Boolean] whether the command exited with status 0
+    def success? = @success
+
+    # @return [Boolean] whether the command exited non-zero
+    def failure? = !@success
+
+    # @return [String] stdout decoded as UTF-8
+    def stdout
+      @stdout ||= @stdout_bytes.dup.force_encoding(Encoding::UTF_8)
+    end
+
+    # @return [String] stderr decoded as UTF-8
+    def stderr
+      @stderr ||= @stderr_bytes.dup.force_encoding(Encoding::UTF_8)
+    end
+
+    def to_s = stdout
+
+    def inspect
+      "#<Microsandbox::SshOutput status=#{@status} success=#{@success} " \
+        "stdout=#{stdout.bytesize}B stderr=#{stderr.bytesize}B>"
+    end
+  end
+
+  # A high-level SFTP session over an {SshClient}, from {SshClient#sftp}. All
+  # paths are guest paths. Mirrors the `SftpClient` of the official SDKs.
+  class SftpClient
+    def initialize(native)
+      @native = native
+    end
+
+    # Read a file's full contents.
+    # @return [String] raw bytes (ASCII-8BIT)
+    def read(path)
+      @native.read(path.to_s)
+    end
+
+    # Read a file and decode it as UTF-8 (lenient).
+    # @return [String]
+    def read_text(path)
+      read(path).force_encoding(Encoding::UTF_8)
+    end
+
+    # Write a file, creating or truncating it.
+    # @return [nil]
+    def write(path, data)
+      @native.write(path.to_s, data.to_s)
+      nil
+    end
+
+    # Create a directory.
+    # @return [nil]
+    def mkdir(path)
+      @native.mkdir(path.to_s)
+      nil
+    end
+
+    # Remove a file.
+    # @return [nil]
+    def remove_file(path)
+      @native.remove_file(path.to_s)
+      nil
+    end
+
+    # Remove an empty directory.
+    # @return [nil]
+    def remove_dir(path)
+      @native.remove_dir(path.to_s)
+      nil
+    end
+
+    # Rename (move) a file or directory.
+    # @return [nil]
+    def rename(old_path, new_path)
+      @native.rename(old_path.to_s, new_path.to_s)
+      nil
+    end
+
+    # Create a symlink at +link_path+ pointing to +target+.
+    # @return [nil]
+    def symlink(target, link_path)
+      @native.symlink(target.to_s, link_path.to_s)
+      nil
+    end
+
+    # Resolve a path to its canonical absolute form.
+    # @return [String]
+    def real_path(path)
+      @native.real_path(path.to_s)
+    end
+
+    # Read a symlink's target.
+    # @return [String]
+    def read_link(path)
+      @native.read_link(path.to_s)
+    end
+
+    # Close the SFTP session. Idempotent.
+    # @return [nil]
+    def close
+      @native.close
+      nil
+    end
+  end
+
+  # A native, in-process SSH client session to a sandbox, from
+  # {SshOps#open_client}. Mirrors the `SshClient` of the official SDKs.
+  #
+  # @example
+  #   sb.ssh.open_client do |client|
+  #     out = client.exec("uname -a")
+  #     puts out.stdout
+  #   end
+  class SshClient
+    def initialize(native)
+      @native = native
+    end
+
+    # Run a command over SSH and collect its output.
+    # @param command [String] the command line (interpreted by the remote shell)
+    # @param tty [Boolean] allocate a pseudo-terminal
+    # @return [SshOutput]
+    def exec(command, tty: false)
+      SshOutput.new(@native.exec(command.to_s, tty ? true : false))
+    end
+
+    # Attach the local terminal to an interactive SSH shell. Host-TTY coupled
+    # (puts the terminal in raw mode and forwards SIGWINCH); blocks until the
+    # remote shell exits or the detach sequence is typed.
+    # @param term [String, nil] TERM value to request (defaults to $TERM)
+    # @param detach_keys [String, nil] detach key sequence (e.g. "ctrl-p,ctrl-q")
+    # @return [Integer] the remote shell's exit status
+    def attach(term: nil, detach_keys: nil)
+      @native.attach(term&.to_s, detach_keys&.to_s)
+    end
+
+    # Open an SFTP session over this connection. With a block, the session is
+    # yielded and closed when the block returns.
+    # @yieldparam sftp [SftpClient]
+    # @return [SftpClient, Object]
+    def sftp
+      session = SftpClient.new(@native.sftp)
+      return session unless block_given?
+
+      begin
+        yield session
+      ensure
+        session.close
+      end
+    end
+
+    # Close the SSH client session. Idempotent.
+    # @return [nil]
+    def close
+      @native.close
+      nil
+    end
+  end
+
+  # A reusable SSH server endpoint for a sandbox, from {SshOps#prepare_server}.
+  # Each {#serve_connection} serves a single SSH transport over this process's
+  # stdin/stdout — typically wired up by a parent SSH daemon via `ForceCommand`
+  # or an inetd-style spawn. Mirrors the `SshServer` of the official SDKs.
+  class SshServer
+    def initialize(native)
+      @native = native
+    end
+
+    # Serve one SSH connection over this process's stdin/stdout. Blocks until
+    # the session ends.
+    # @return [nil]
+    def serve_connection
+      @native.serve_connection
+      nil
+    end
+
+    # Release the prepared server endpoint. Idempotent.
+    # @return [nil]
+    def close
+      @native.close
+      nil
+    end
+  end
+
+  # The SSH namespace for a sandbox, returned by {Sandbox#ssh}. Use it to open a
+  # native in-process SSH client or prepare a reusable server endpoint.
+  class SshOps
+    def initialize(native)
+      @native = native
+    end
+
+    # Open a native in-process SSH client to the sandbox. With a block, the
+    # client is yielded and closed when the block returns.
+    # @param user [String] guest user to authenticate as (default "root")
+    # @param term [String, nil] TERM value for the session
+    # @param sftp [Boolean] enable the SFTP subsystem (default true)
+    # @yieldparam client [SshClient]
+    # @return [SshClient, Object]
+    def open_client(user: "root", term: nil, sftp: true)
+      opts = {"user" => user.to_s, "sftp" => sftp ? true : false}
+      opts["term"] = term.to_s if term
+      client = SshClient.new(@native.ssh_open_client(opts))
+      return client unless block_given?
+
+      begin
+        yield client
+      ensure
+        client.close
+      end
+    end
+
+    # Prepare a reusable SSH server endpoint for the sandbox.
+    # @param host_key_path [String, nil] PEM host key path (generated if omitted)
+    # @param authorized_keys_path [String, nil] authorized_keys file path
+    # @param user [String, nil] guest user connections run as
+    # @param sftp [Boolean] enable the SFTP subsystem (default true)
+    # @return [SshServer]
+    def prepare_server(host_key_path: nil, authorized_keys_path: nil, user: nil, sftp: true)
+      opts = {"sftp" => sftp ? true : false}
+      opts["host_key_path"] = host_key_path.to_s if host_key_path
+      opts["authorized_keys_path"] = authorized_keys_path.to_s if authorized_keys_path
+      opts["user"] = user.to_s if user
+      SshServer.new(@native.ssh_prepare_server(opts))
+    end
+  end
+end

data/lib/microsandbox/version.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 module Microsandbox
-  # Gem version. Tracks the upstream microsandbox runtime (currently `v0.5.7`,
+  # Gem version. Tracks the upstream microsandbox runtime (currently `v0.5.8`,
   # the pinned core-crate tag); the patch segment advances for gem-only revisions
   # that add bindings atop the same core. Must equal the native ext's Cargo crate
   # version (`Native.version`), enforced by spec/unit/version_spec.rb.
-  VERSION = "0.5.8"
+  VERSION = "0.5.10"
 end

data/lib/microsandbox/volume.rb

@@ -7,7 +7,7 @@ module Microsandbox
   # (`kind`, `used_bytes`, …) are populated when returned from {Volume.get}/{Volume.list}.
   class VolumeInfo
     attr_reader :name, :path, :quota_mib, :used_bytes, :capacity_bytes,
-                :disk_format, :disk_fstype, :labels
+      :disk_format, :disk_fstype, :labels
 
     def initialize(data)
       @name = data["name"]
@@ -33,7 +33,7 @@ module Microsandbox
     end
 
     def inspect
-      "#<Microsandbox::VolumeInfo name=#{@name.inspect}#{@kind ? " kind=#{@kind}" : ""}>"
+      "#<Microsandbox::VolumeInfo name=#{@name.inspect}#{" kind=#{@kind}" if @kind}>"
     end
   end
 
@@ -49,7 +49,7 @@ module Microsandbox
       # @param labels [Hash, nil]
       # @return [VolumeInfo]
       def create(name, kind: "dir", size_mib: nil, quota_mib: nil, labels: nil)
-        opts = { "kind" => kind.to_s }
+        opts = {"kind" => kind.to_s}
         opts["size_mib"] = Integer(size_mib) if size_mib
         opts["quota_mib"] = Integer(quota_mib) if quota_mib
         opts["labels"] = labels.each_with_object({}) { |(k, v), a| a[k.to_s] = v.to_s } if labels

data/lib/microsandbox.rb

@@ -22,6 +22,10 @@ require_relative "microsandbox/streams"
 require_relative "microsandbox/image"
 require_relative "microsandbox/volume"
 require_relative "microsandbox/snapshot"
+require_relative "microsandbox/patch"
+require_relative "microsandbox/network"
+require_relative "microsandbox/agent"
+require_relative "microsandbox/ssh"
 require_relative "microsandbox/sandbox"
 
 # Microsandbox — lightweight microVM sandboxes for Ruby.
@@ -74,6 +78,11 @@ module Microsandbox
     # @return [nil]
     def ensure_runtime!
       return if @runtime_ready
+      # A cloud backend has no local msb/libkrunfw runtime to provision: skip the
+      # presence check and the first-use download entirely. Resolving the kind
+      # uses the same lazy env/profile/config ladder every operation already
+      # consults, so this adds no work for local hosts (the common case).
+      return if default_backend_kind == :cloud
       if installed?
         @runtime_ready = true
         return
@@ -100,6 +109,62 @@ module Microsandbox
       Native.set_runtime_msb_path(path.to_s)
     end
 
+    # Override the `libkrunfw` shared-library path (SDK tier of the resolver,
+    # below the `MSB_LIBKRUNFW_PATH` environment variable). Process-level and
+    # set-once: a second call is silently ignored, and the env var still wins.
+    # Mirrors {runtime_path=} for libkrunfw.
+    # @param path [String]
+    # @return [void]
+    def libkrunfw_path=(path)
+      Native.set_runtime_libkrunfw_path(path.to_s)
+    end
+
+    # Install a process-wide default backend (v0.5.8 backend routing). Without a
+    # call to this, operations use a local libkrun backend; the env/profile
+    # ladder (`MSB_BACKEND`, `MSB_API_URL`+`MSB_API_KEY`, `MSB_PROFILE`,
+    # `~/.microsandbox/config.json`) is resolved lazily on first use. Call once
+    # at startup, before any sandbox operations.
+    #
+    # @param kind ["local","cloud", Symbol] backend kind
+    # @param url [String, nil] cloud control-plane URL (cloud, unless `profile:`)
+    # @param api_key [String, nil] cloud API key (cloud, unless `profile:`)
+    # @param profile [String, nil] named profile from `~/.microsandbox/config.json`
+    # @return [void]
+    def set_default_backend(kind, url: nil, api_key: nil, profile: nil)
+      Native.set_default_backend(kind.to_s, url&.to_s, api_key&.to_s, profile&.to_s)
+    end
+
+    # Run the given block with a temporary default backend, restoring the
+    # previous one afterward (even on error). NOTE: the swap is process-wide
+    # while the block runs, not fiber/thread-local — concurrent threads observe
+    # the temporary backend. It is also NOT safe to call from multiple threads
+    # at once: two interleaved `with_backend` calls can restore each other's
+    # saved backend out of order and leave a temporary backend installed
+    # permanently. Use it only when no other thread is changing the backend, and
+    # avoid calling {set_default_backend} inside the block (the restore on exit
+    # would overwrite that change). Mirrors the official SDKs' scoped-backend helper.
+    #
+    # @param kind ["local","cloud", Symbol]
+    # @param url [String, nil]
+    # @param api_key [String, nil]
+    # @param profile [String, nil]
+    # @yield with the temporary backend installed
+    # @return [Object] the block's return value
+    def with_backend(kind, url: nil, api_key: nil, profile: nil)
+      token = Native.push_default_backend(kind.to_s, url&.to_s, api_key&.to_s, profile&.to_s)
+      begin
+        yield
+      ensure
+        Native.pop_default_backend(token)
+      end
+    end
+
+    # @return [Symbol] the active default backend kind, :local or :cloud.
+    #   The first call resolves the env/profile/config ladder.
+    def default_backend_kind
+      Native.default_backend_kind.to_sym
+    end
+
     # Latest resource-usage snapshot for every running sandbox, keyed by name.
     # Mirrors the official `all_sandbox_metrics`/`allSandboxMetrics` helpers.
     # @return [Hash{String => Metrics}]

data/sig/microsandbox.rbs

@@ -9,8 +9,13 @@ module Microsandbox
   def self.ensure_runtime!: () -> nil
   def self.runtime_path: () -> String
   def self.runtime_path=: (String path) -> void
+  def self.libkrunfw_path=: (String path) -> void
   def self.all_sandbox_metrics: () -> Hash[String, Metrics]
 
+  def self.set_default_backend: (String | Symbol kind, ?url: String?, ?api_key: String?, ?profile: String?) -> void
+  def self.with_backend: [T] (String | Symbol kind, ?url: String?, ?api_key: String?, ?profile: String?) { () -> T } -> T
+  def self.default_backend_kind: () -> Symbol
+
   class Error < StandardError
     def self.code: () -> String
     def code: () -> String
@@ -37,6 +42,8 @@ module Microsandbox
   class MetricsDisabledError < Error end
   class MetricsUnavailableError < Error end
   class UnsupportedOperationError < Error end
+  class CloudHttpError < Error end
+  class UnsupportedError < Error end
 
   class ExecOutput
     def initialize: (Hash[String, untyped] data) -> void
@@ -114,15 +121,26 @@ module Microsandbox
     def timestamp: () -> Time
   end
 
-  class SandboxInfo
+  class SandboxHandle
     def name: () -> String
     def status: () -> Symbol
     def running?: () -> bool
     def stopped?: () -> bool
     def created_at: () -> Time?
     def updated_at: () -> Time?
+    def stop: () -> nil
+    def stop_with_timeout: (Numeric timeout) -> nil
+    def kill: () -> nil
+    def kill_with_timeout: (Numeric timeout) -> nil
+    def request_stop: () -> nil
+    def request_kill: () -> nil
+    def request_drain: () -> nil
+    def wait_until_stopped: () -> SandboxStopResult
   end
 
+  # Deprecated alias for SandboxHandle (was a read-only metadata type pre-v0.5.8).
+  SandboxInfo: singleton(SandboxHandle)
+
   class SandboxStopResult
     def name: () -> String
     def status: () -> Symbol
@@ -140,7 +158,8 @@ module Microsandbox
                       ?user: String?, ?hostname: String?, ?labels: Hash[untyped, untyped]?,
                       ?scripts: Hash[untyped, untyped]?, ?entrypoint: Array[String]?,
                       ?ports: Hash[untyped, untyped]?, ?ports_udp: Hash[untyped, untyped]?,
-                      ?volumes: Hash[untyped, untyped]?, ?network: untyped?, ?from_snapshot: String?,
+                      ?volumes: Hash[untyped, untyped]?, ?network: untyped?,
+                      ?patches: Array[Hash[untyped, untyped]]?, ?from_snapshot: String?,
                       ?log_level: (String | Symbol)?, ?quiet_logs: bool, ?security: (String | Symbol)?,
                       ?oci_upper_size: Integer?, ?max_duration: Integer?, ?idle_timeout: Integer?,
                       ?rlimits: Hash[untyped, untyped]?, ?pull_policy: (String | Symbol)?,
@@ -150,9 +169,9 @@ module Microsandbox
                       ?replace: bool, ?replace_with_timeout: Numeric?)
                       ?{ (Sandbox) -> untyped } -> untyped
     def self.start: (String name, ?detached: bool) -> Sandbox
-    def self.get: (String name) -> SandboxInfo
-    def self.list: () -> Array[SandboxInfo]
-    def self.list_with: (?labels: Hash[untyped, untyped]) -> Array[SandboxInfo]
+    def self.get: (String name) -> SandboxHandle
+    def self.list: () -> Array[SandboxHandle]
+    def self.list_with: (?labels: Hash[untyped, untyped]) -> Array[SandboxHandle]
     def self.remove: (String name) -> nil
 
     def name: () -> String
@@ -162,23 +181,28 @@ module Microsandbox
     def shell: (String script, ?cwd: String?, ?user: String?, ?env: Hash[untyped, untyped]?,
                 ?timeout: Numeric?, ?tty: bool, ?stdin: String?, ?rlimits: Hash[untyped, untyped]?) -> ExecOutput
     def exec_stream: (String command, ?Array[String] args, ?cwd: String?, ?user: String?,
-                      ?env: Hash[untyped, untyped]?, ?timeout: Numeric?, ?tty: bool, ?stdin: String?,
+                      ?env: Hash[untyped, untyped]?, ?timeout: Numeric?, ?tty: bool, ?stdin: (String | :pipe)?,
                       ?rlimits: Hash[untyped, untyped]?) -> ExecHandle
     def shell_stream: (String script, ?cwd: String?, ?user: String?, ?env: Hash[untyped, untyped]?,
-                       ?timeout: Numeric?, ?tty: bool, ?stdin: String?, ?rlimits: Hash[untyped, untyped]?) -> ExecHandle
+                       ?timeout: Numeric?, ?tty: bool, ?stdin: (String | :pipe)?, ?rlimits: Hash[untyped, untyped]?) -> ExecHandle
+    def attach: (String command, ?Array[String] args, ?cwd: String?, ?user: String?,
+                 ?env: Hash[untyped, untyped]?, ?detach_keys: String?,
+                 ?rlimits: Hash[untyped, untyped]?) -> Integer
+    def attach_shell: () -> Integer
     def fs: () -> FS
+    def ssh: () -> SshOps
     def metrics: () -> Metrics
     def logs: (?tail: Integer?, ?since_ms: Numeric?, ?until_ms: Numeric?,
                ?sources: Array[String | Symbol]?) -> Array[LogEntry]
     def metrics_stream: (?interval: Numeric) -> MetricsStream
     def log_stream: (?sources: Array[String | Symbol]?, ?since_ms: Numeric?,
                      ?from_cursor: String?, ?until_ms: Numeric?, ?follow: bool) -> LogStream
-    def stop: (?timeout: Numeric?) -> nil
-    def kill: (?timeout: Numeric?) -> nil
-    def request_stop: () -> nil
-    def request_kill: () -> nil
-    def request_drain: () -> nil
-    def wait_until_stopped: () -> SandboxStopResult
+    def stop: () -> nil
+    def stop_and_wait: () -> ExitStatus
+    def kill: () -> nil
+    def drain: () -> nil
+    def wait: () -> ExitStatus
+    def status: () -> Symbol
     def owns_lifecycle?: () -> bool
     def detach: () -> nil
   end
@@ -210,7 +234,7 @@ module Microsandbox
   end
 
   class ExitStatus
-    def exit_code: () -> Integer
+    def exit_code: () -> Integer?
     def success?: () -> bool
     def failure?: () -> bool
   end
@@ -321,4 +345,130 @@ module Microsandbox
                       ?with_image: bool, ?plain_tar: bool) -> nil
     def self.import: (String archive_path, ?dest: String?) -> SnapshotInfo
   end
+
+  module Patch
+    def self.text: (String path, String content, ?mode: Integer?, ?replace: bool) -> Hash[String, untyped]
+    def self.file: (String path, String content, ?mode: Integer?, ?replace: bool) -> Hash[String, untyped]
+    def self.append: (String path, String content) -> Hash[String, untyped]
+    def self.copy_file: (String src, String dst, ?mode: Integer?, ?replace: bool) -> Hash[String, untyped]
+    def self.copy_dir: (String src, String dst, ?replace: bool) -> Hash[String, untyped]
+    def self.symlink: (String target, String link, ?replace: bool) -> Hash[String, untyped]
+    def self.mkdir: (String path, ?mode: Integer?) -> Hash[String, untyped]
+    def self.remove: (String path) -> Hash[String, untyped]
+  end
+
+  module Destination
+    def self.any: () -> Hash[String, String]
+    def self.ip: (String value) -> Hash[String, String]
+    def self.cidr: (String value) -> Hash[String, String]
+    def self.domain: (String value) -> Hash[String, String]
+    def self.domain_suffix: (String value) -> Hash[String, String]
+    def self.group: ((String | Symbol) value) -> Hash[String, String]
+  end
+
+  module Rule
+    def self.allow: (?destination: untyped?, ?direction: (String | Symbol),
+                     ?protocol: (String | Symbol)?, ?protocols: Array[String | Symbol]?,
+                     ?port: (String | Integer)?, ?ports: Array[String | Integer]?) -> Hash[String, untyped]
+    def self.deny: (?destination: untyped?, ?direction: (String | Symbol),
+                    ?protocol: (String | Symbol)?, ?protocols: Array[String | Symbol]?,
+                    ?port: (String | Integer)?, ?ports: Array[String | Integer]?) -> Hash[String, untyped]
+  end
+
+  class NetworkPolicy
+    PRESET_ALIASES: Hash[String, String]
+    def self.public_only: () -> NetworkPolicy
+    def self.none: () -> NetworkPolicy
+    def self.allow_all: () -> NetworkPolicy
+    def self.non_local: () -> NetworkPolicy
+    def self.preset: ((String | Symbol) name) -> NetworkPolicy
+    def self.custom: (?default_egress: (String | Symbol)?, ?default_ingress: (String | Symbol)?,
+                      ?rules: Array[Hash[untyped, untyped]], ?deny_domains: Array[String],
+                      ?deny_domain_suffixes: Array[String]) -> NetworkPolicy
+    def self.coerce: (untyped network) -> Hash[String, untyped]
+    def initialize: (Hash[String, untyped] wire) -> void
+    def to_h: () -> Hash[String, untyped]
+  end
+
+  class AgentFrame
+    def initialize: (Hash[String, untyped] data) -> void
+    def id: () -> Integer
+    def flags: () -> Integer
+    def body: () -> String
+    def terminal?: () -> bool
+    def session_start?: () -> bool
+    def shutdown?: () -> bool
+  end
+
+  class AgentStream
+    include Enumerable[AgentFrame]
+    def id: () -> Integer
+    def recv: () -> AgentFrame?
+    def each: () { (AgentFrame) -> void } -> self
+            | () -> Enumerator[AgentFrame, self]
+    def close: () -> nil
+  end
+
+  class AgentClient
+    FLAG_TERMINAL: Integer
+    FLAG_SESSION_START: Integer
+    FLAG_SHUTDOWN: Integer
+    def self.connect_sandbox: (String name, ?timeout: Numeric?) ?{ (AgentClient) -> untyped } -> untyped
+    def self.connect_path: (String path, ?timeout: Numeric?) ?{ (AgentClient) -> untyped } -> untyped
+    def self.socket_path: (String name) -> String
+    def initialize: (untyped native) -> void
+    def request: (Integer flags, String body) -> AgentFrame
+    def stream: (Integer flags, String body) -> AgentStream
+    def send_frame: (Integer id, Integer flags, String body) -> nil
+    def ready_bytes: () -> String
+    def close: () -> nil
+  end
+
+  class SshOutput
+    def initialize: (Hash[String, untyped] data) -> void
+    def status: () -> Integer
+    def success?: () -> bool
+    def failure?: () -> bool
+    def stdout: () -> String
+    def stderr: () -> String
+    def stdout_bytes: () -> String
+    def stderr_bytes: () -> String
+    def to_s: () -> String
+  end
+
+  class SftpClient
+    def initialize: (untyped native) -> void
+    def read: (String path) -> String
+    def read_text: (String path) -> String
+    def write: (String path, String data) -> nil
+    def mkdir: (String path) -> nil
+    def remove_file: (String path) -> nil
+    def remove_dir: (String path) -> nil
+    def rename: (String old_path, String new_path) -> nil
+    def symlink: (String target, String link_path) -> nil
+    def real_path: (String path) -> String
+    def read_link: (String path) -> String
+    def close: () -> nil
+  end
+
+  class SshClient
+    def initialize: (untyped native) -> void
+    def exec: (String command, ?tty: bool) -> SshOutput
+    def attach: (?term: String?, ?detach_keys: String?) -> Integer
+    def sftp: () ?{ (SftpClient) -> untyped } -> untyped
+    def close: () -> nil
+  end
+
+  class SshServer
+    def initialize: (untyped native) -> void
+    def serve_connection: () -> nil
+    def close: () -> nil
+  end
+
+  class SshOps
+    def initialize: (untyped native) -> void
+    def open_client: (?user: String, ?term: String?, ?sftp: bool) ?{ (SshClient) -> untyped } -> untyped
+    def prepare_server: (?host_key_path: String?, ?authorized_keys_path: String?,
+                         ?user: String?, ?sftp: bool) -> SshServer
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: microsandbox-rb
 version: !ruby/object:Gem::Version
-  version: 0.5.8
+  version: 0.5.10
 platform: ruby
 authors:
 - ya-luotao
@@ -45,6 +45,8 @@ files:
 - README.md
 - ext/microsandbox/Cargo.toml
 - ext/microsandbox/extconf.rb
+- ext/microsandbox/src/agent.rs
+- ext/microsandbox/src/backend.rs
 - ext/microsandbox/src/conv.rs
 - ext/microsandbox/src/error.rs
 - ext/microsandbox/src/exec.rs
@@ -53,9 +55,11 @@ files:
 - ext/microsandbox/src/runtime.rs
 - ext/microsandbox/src/sandbox.rs
 - ext/microsandbox/src/snapshot.rs
+- ext/microsandbox/src/ssh.rs
 - ext/microsandbox/src/stream.rs
 - ext/microsandbox/src/volume.rs
 - lib/microsandbox.rb
+- lib/microsandbox/agent.rb
 - lib/microsandbox/errors.rb
 - lib/microsandbox/exec_handle.rb
 - lib/microsandbox/exec_output.rb
@@ -63,8 +67,11 @@ files:
 - lib/microsandbox/image.rb
 - lib/microsandbox/log_entry.rb
 - lib/microsandbox/metrics.rb
+- lib/microsandbox/network.rb
+- lib/microsandbox/patch.rb
 - lib/microsandbox/sandbox.rb
 - lib/microsandbox/snapshot.rb
+- lib/microsandbox/ssh.rb
 - lib/microsandbox/streams.rb
 - lib/microsandbox/version.rb
 - lib/microsandbox/volume.rb