Bos_os_cmd (bos.bos.Bos_os

val unix_buffer_size : int

val pp_unix_error : Format.formatter -> Unix.error -> unit

val pp_process_status : Format.formatter -> Unix.process_status -> unit

val err_empty_line : string

val err_run : 
  string list ->
  (Format.formatter -> 'a -> unit) ->
  'a ->
  ('b, [> Rresult.R.msg ]) Rresult.result

val waitpid : Unix.wait_flag list -> int -> int * Unix.process_status

val create_process_env : 
  string ->
  string array ->
  string array ->
  Unix.file_descr ->
  Unix.file_descr ->
  Unix.file_descr ->
  int

val pipe : unit -> Unix.file_descr * Unix.file_descr

val set_close_on_exec : Unix.file_descr -> unit

val clear_close_on_exec : Unix.file_descr -> unit

val openfile : 
  string ->
  Unix.open_flag list ->
  Unix.file_perm ->
  Unix.file_descr

val close : Unix.file_descr -> unit

val close_no_err : Unix.file_descr -> unit

val select : 
  Unix.file_descr list ->
  Unix.file_descr list ->
  Unix.file_descr list ->
  float ->
  Unix.file_descr list * Unix.file_descr list * Unix.file_descr list

val create_process : 
  string list ->
  string Astring.String.Map.t option ->
  stdin:Unix.file_descr ->
  stdout:Unix.file_descr ->
  stderr:Unix.file_descr ->
  int

val default_path_sep : string

val dir_sep : char

val exe_is_path : string -> bool

val tool_file : dir:string -> string -> string

val search_in_path : string -> Fpath.t option

val search_in_dirs : dirs:Fpath.t list -> string -> Fpath.t option

val ensure_exe_suffix_if_win32 : string -> string

val _find_tool : 
  ?search:Fpath.t list ->
  string ->
  (Fpath.t option, [> `Msg of string ]) Rresult.result

val find_tool : 
  ?search:Fpath.t list ->
  string list ->
  (Fpath.t option, [> `Msg of string ]) Rresult.result

val err_not_found : 
  ?search:Fpath.t list ->
  string list ->
  ('a, [> Rresult.R.msg ]) Rresult.result

val get_tool : 
  ?search:Fpath.t list ->
  string list ->
  (Fpath.t, [> Rresult.R.msg ]) Rresult.result

val exists : 
  ?search:Fpath.t list ->
  string list ->
  (bool, [> `Msg of string ]) Rresult.result

val must_exist : 
  ?search:Fpath.t list ->
  string list ->
  (string list, [> Rresult.R.msg ]) Rresult.result

val resolve : 
  ?search:Fpath.t list ->
  string list ->
  (string list, [> Rresult.R.msg ]) Rresult.result

val search_path_dirs : 
  ?sep:string ->
  string ->
  (Fpath.t list, [> Rresult.R.msg ]) Rresult.result

module Fds : sig ... end

val write_fd_for_file : 
  append:bool ->
  Fpath.t ->
  (Unix.file_descr, [> Rresult.R.msg ]) Rresult.result

val read_fd_for_file : 
  Fpath.t ->
  (Unix.file_descr, [> Rresult.R.msg ]) Rresult.result

val string_of_fd_async : 
  Unix.file_descr ->
  (unit ->
  [> `Await of 'a | `Ok of string ]) as 'a

val string_of_fd : Unix.file_descr -> string

val string_to_fd_async : 
  string ->
  Unix.file_descr ->
  (unit ->
  [> `Await of 'a | `Ok of unit ]) as 'a

val string_to_fd : string -> Unix.file_descr -> unit

val string_to_of_fd : 
  string ->
  to_fd:Unix.file_descr ->
  of_fd:Unix.file_descr ->
  string

type status = [

| `Exited of int
| `Signaled of int

]

type run_info = Bos_cmd.t

val run_info_cmd : 'a -> 'a

val pp_status : 
  Format.formatter ->
  [< `Exited of int | `Signaled of int ] ->
  unit

type run_status = run_info * status

val success : 
  ('a * (string list * [< `Exited of int | `Signaled of int Exited ]),
    [> Rresult.R.msg ] as 'b)
    Rresult.result ->
  ('a, 'b) Rresult.result

type run_err =

| Err_file of Fpath.t * bool
| Err_fd of Unix.file_descr
| Err_run_out
| Err_stderr

val err_file : ?append:bool -> Fpath.t -> run_err

val err_null : run_err

val err_run_out : run_err

val err_stderr : run_err

val fd_for_run_err : 
  Unix.file_descr ->
  run_err ->
  (Unix.file_descr, [> Rresult.R.msg ]) Rresult.result

type pipeline = {

write : (string * Unix.file_descr) option;
read : Unix.file_descr;
pids : (Bos_cmd.t * int) list;

}

type run_in =

| In_string of string
| In_file of Fpath.t
| In_run_out of pipeline
| In_fd of Unix.file_descr

val in_string : string -> run_in

val in_file : Fpath.t -> run_in

val in_null : run_in

val in_stdin : run_in

type _ _run_out =

| To_string : (string * run_status) _run_out
| To_file : Fpath.t * bool -> (unit * run_status) _run_out
| To_run_in : run_in _run_out
| To_fd : Unix.file_descr -> (unit * run_status) _run_out

type run_out = {

env : Bos_os_env.t option;
cmd : Bos_cmd.t;
run_err : run_err;
run_in : run_in;

}

val wait_pids : ('a * int) list -> 'a * [> `Exited of int | `Signaled of int ]

val do_in_fd_read_stdout : 
  Fds.S.elt ->
  run_out ->
  (Bos_cmd.t * int) list ->
  (Fds.S.t ref ->
    Unix.file_descr ->
    (Bos_cmd.t * int) list ->
    ('a, [> Rresult.R.msg ] as 'b) Rresult.result) ->
  ('a, 'b) Rresult.result

val do_in_fd_out_string : 
  Fds.S.elt ->
  run_out ->
  (Bos_cmd.t * int) list ->
  (string * (Bos_cmd.t * [> `Exited of int | `Signaled of int ]),
    [> Rresult.R.msg ])
    Rresult.result

val do_in_fd_out_run_in : 
  Fds.S.elt ->
  run_out ->
  (Bos_cmd.t * int) list ->
  (run_in, [> Rresult.R.msg ]) Rresult.result

val do_in_fd_out_fd : 
  Fds.S.elt ->
  Fds.S.elt ->
  run_out ->
  (Bos_cmd.t * int) list ->
  (unit * (Bos_cmd.t * [> `Exited of int | `Signaled of int ]),
    [> Rresult.R.msg ])
    Rresult.result

val do_in_run_out_string : 
  pipeline ->
  run_out ->
  (string * (Bos_cmd.t * [> `Exited of int | `Signaled of int ]),
    [> Rresult.R.msg ])
    Rresult.result

val do_in_run_out_run_in : 
  pipeline ->
  run_out ->
  (run_in, [> Rresult.R.msg ]) Rresult.result

val do_in_run_out_fd : 
  pipeline ->
  Fds.S.elt ->
  run_out ->
  (unit * (Bos_cmd.t * [> `Exited of int | `Signaled of int ]),
    [> Rresult.R.msg ])
    Rresult.result

val do_in_string_read_stdout : 
  'a ->
  run_out ->
  (Fds.S.t ref ->
    Unix.file_descr ->
    Unix.file_descr ->
    int ->
    ('b, [> Rresult.R.msg ] as 'c) Rresult.result) ->
  ('b, 'c) Rresult.result

val do_in_string_out_string : 
  string ->
  run_out ->
  (string * (Bos_cmd.t * [> `Exited of int | `Signaled of int ]),
    [> Rresult.R.msg ])
    Rresult.result

val do_in_string_out_run_in : 
  string ->
  run_out ->
  (run_in, [> Rresult.R.msg ]) Rresult.result

val do_in_string_out_fd : 
  string ->
  Fds.S.elt ->
  run_out ->
  (unit * (Bos_cmd.t * [> `Exited of int | `Signaled of int ]),
    [> Rresult.R.msg ])
    Rresult.result

val do_in_fd : 
  'a. Unix.file_descr ->
  run_out ->
  'a _run_out ->
  ('a, [> Rresult.R.msg ]) Rresult.result

val run_cmd : 
  'a. run_out ->
  'a _run_out ->
  ('a, [> Rresult.R.msg ]) Rresult.result

val out_string : 
  ?trim:bool ->
  run_out ->
  (string * run_status, [> Rresult.R.msg ]) Rresult.result

val out_lines : 
  ?trim:bool ->
  run_out ->
  (string list * run_status, [> Rresult.R.msg ]) Rresult.result

val out_file : 
  ?append:bool ->
  Fpath.t ->
  run_out ->
  (unit * run_status, [> Rresult.R.msg ]) Rresult.result

val out_run_in : run_out -> (run_in, [> Rresult.R.msg ]) Rresult.result

val out_null : 
  run_out ->
  (unit * run_status, [> Rresult.R.msg ]) Rresult.result

val out_stdout : 
  run_out ->
  (unit * run_status, [> Rresult.R.msg ]) Rresult.result

val to_string : 
  ?trim:bool ->
  run_out ->
  (string, [> Rresult.R.msg ]) Rresult.result

val to_lines : 
  ?trim:bool ->
  run_out ->
  (string list, [> Rresult.R.msg ]) Rresult.result

val to_file : 
  ?append:bool ->
  Fpath.t ->
  run_out ->
  (unit, [> Rresult.R.msg ]) Rresult.result

val to_null : run_out -> (unit, [> Rresult.R.msg ]) Rresult.result

val to_stdout : run_out -> (unit, [> Rresult.R.msg ]) Rresult.result

val run_io : 
  ?env:Bos_os_env.t ->
  ?err:run_err ->
  Bos_cmd.t ->
  run_in ->
  run_out

val run_out : ?env:Bos_os_env.t -> ?err:run_err -> Bos_cmd.t -> run_out

val run_in : 
  ?env:Bos_os_env.t ->
  ?err:run_err ->
  Bos_cmd.t ->
  run_in ->
  (unit, [> Rresult.R.msg ]) Rresult.result

val run : 
  ?env:Bos_os_env.t ->
  ?err:run_err ->
  Bos_cmd.t ->
  (unit, [> Rresult.R.msg ]) Rresult.result

val run_status : 
  ?env:Bos_os_env.t ->
  ?err:run_err ->
  ?quiet:bool ->
  Bos_cmd.t ->
  (status, [> Rresult.R.msg ]) Rresult.result