sig
  type 'a with_process_flags =
      ?use_extra_path:bool ->
      ?timeout:Core.Std.Time.Span.t option ->
      ?working_dir:string ->
      ?setuid:int ->
      ?setgid:int ->
      ?env:[ `Extend of (string * string) list
           | `Replace of (string * string) list ] ->
      ?verbose:bool ->
      ?echo:bool -> ?input:string -> ?keep_open:bool -> ?tail_len:int -> 'a
  type 'a with_run_flags = ?expect:int list -> 'a with_process_flags
  type 'a cmd = string -> string list -> 'a
  val run : unit cmd with_run_flags
  val run_lines : ?eol:char -> string list cmd with_run_flags
  val run_one : ?eol:char -> string option cmd with_run_flags
  val run_one_exn : ?eol:char -> string cmd with_run_flags
  val run_full : string cmd with_run_flags
  val run_fold :
    ?eol:char ->
    init:'a ->
    f:('a -> string -> 'a * [ `Continue | `Stop ]) -> 'a cmd with_run_flags
  type ('a, 'ret) sh_cmd = ('a, unit, string, 'ret) format4 -> 'a
  val sh : ('a, unit) sh_cmd with_run_flags
  val sh_lines : ('a, string list) sh_cmd with_run_flags
  val sh_full : ('a, string) sh_cmd with_run_flags
  val sh_one : ('a, string option) sh_cmd with_run_flags
  val sh_one_exn : ('a, string) sh_cmd with_run_flags
  val noninteractive_ssh_options : string list
  val noninteractive_no_hostkey_checking_options : string list
  type 'a with_ssh_flags =
      ?ssh_options:string list -> ?user:string -> host:string -> 'a
  val ssh : ('a, unit) sh_cmd with_run_flags with_ssh_flags
  val ssh_lines : ('a, string list) sh_cmd with_run_flags with_ssh_flags
  val ssh_full : ('a, string) sh_cmd with_run_flags with_ssh_flags
  val ssh_one : ('a, string option) sh_cmd with_run_flags with_ssh_flags
  val ssh_one_exn : ('a, string) sh_cmd with_run_flags with_ssh_flags
  type 'a with_test_flags =
      ?true_v:int list -> ?false_v:int list -> 'a with_process_flags
  val test : bool cmd with_test_flags
  val sh_test : ('a, bool) sh_cmd with_test_flags
  val ssh_test : ('a, bool) sh_cmd with_test_flags with_ssh_flags
  val extra_path : string list ref
  module Process :
    sig
      type status =
          [ `Exited of int
          | `Signaled of Core.Std.Signal.t
          | `Timeout of Core.Std.Time.Span.t ]
      type t = Shell.Process.t
      type result =
        Shell.Process.result = {
        command : t;
        status : status;
        stdout : string;
        stderr : string;
      }
      exception Failed of result
      val to_string : t -> string
      val status_to_string : status -> string
      val set_defaults :
        ?timeout:Core.Std.Time.Span.t option ->
        ?verbose:bool -> ?echo:bool -> unit -> unit
      val format_failed : result -> string
      val cmd : string -> string list -> t
      val shell : string -> t
      val make_ssh_command :
        ?ssh_options:string list ->
        ?quote_args:bool -> ?user:string -> host:string -> string list -> t
      val remote :
        ?ssh_options:string list ->
        ?quote_args:bool -> ?user:string -> host:string -> t -> t
      type 'a reader = 'a Shell.Process.reader
      val content : string reader
      val content_and_stderr : (string * string) reader
      val discard : unit reader
      val lines : ?eol:char -> unit -> string list reader
      val head : ?eol:char -> unit -> string option reader
      exception Empty_head
      val head_exn : ?eol:char -> unit -> string reader
      val callback :
        add:(string -> int -> unit) -> flush:(unit -> unit) -> unit reader
      val run : (t -> 'a reader -> 'a) with_run_flags
      val run_k : ((t -> 'a reader -> 'a) -> 'b) -> 'b with_run_flags
      val test : (t -> bool) with_test_flags
      val test_k : ((t -> bool) -> 'a) -> 'a with_test_flags
    end
  val mkdir : ?p:unit -> ?perm:int -> string -> unit
  val cp :
    ?overwrite:bool ->
    ?perm:Core.Std.Unix.file_perm -> string -> string -> unit
  val ln : ?s:unit -> ?f:unit -> string -> string -> unit
  val rm : ?r:unit -> ?f:unit -> string -> unit
  val mv : string -> string -> unit
  val whoami : ?real:bool -> unit -> string
  val which : ?use_extra_path:bool -> string -> string option
  val scp :
    ?compress:bool ->
    ?recurse:bool -> ?user:string -> host:string -> string -> string -> unit
end