Provided by: zeroinstall-injector_1.6-1ubuntu1_all bug

NAME

       0install — a decentralised software installation system

SYNOPSIS

   Downloading and running:
       0install select URI

       0install download URI

       0install run URI [ARG]...

       0install update URI

   Other commands:
       0install config [NAME [VALUE]]

       0install import FEED

       0install list PATTERN

       0install add-feed FEED

       0install remove-feed [INTERFACE] FEED

       0install list-feeds URI

       0install digest DIRECTORY | ARCHIVE [EXTRACT]

DESCRIPTION

       Zero  Install is a decentralised cross-distribution software installation system. Programs
       and libraries are identified by URIs, and there is no need for a central repository.  Zero
       Install  ensures  that  packages  cannot conflict with each other and that programs can be
       shared between mutually untrusting users. See the web-site for more information:

       http://0install.net/

       The simplest case is to ask 0install to run a program, given its URI. For example:

       0install run http://rox.sourceforge.net/2005/interfaces/Edit

       The first time you do this, details about available versions of the program are downloaded
       and cached, along with details about any libraries it depends on.

       Zero  Install  will  run a solver to select the best version of each component to use. For
       example, it will select binaries that are compatible with your CPU and  operating  system,
       in your preferred language, and marked "stable" (by default).

       If  $DISPLAY  is set, 0install will display a window where you can confirm (or change) the
       selected versions.

       It will then download the corresponding archives for those versions and store them in  the
       cache too. Each package unpacks to its own directory.

       Finally,  0install will launch the program, setting environment variables to let it locate
       its libraries.

GLOBAL OPTIONS

       The first non-option argument to 0install  is  the  particular  sub-command  you  want  to
       perform; these are described in detail in the next section.

       However, there are some options that apply to all operations. These are:

       -c, --console
              Never  use  the  GUI.  Normally, 0install switches to graphical mode if it needs to
              download anything from the network (unless DISPLAY is not set).

       -h, --help
              Show the built-in help text.

       -o, --offline
              Run in off-line mode, overriding the default setting. This prevents  0install  from
              checking for updates, and from downloading updates even if it knows about them.

       -v, --verbose
              More verbose output. Use twice for even more verbose output.

       --with-store=DIR
              Append  a directory to the list of implementation caches. Each sub-directory of DIR
              contains the contents of one version of a program or library.

SUB-COMMANDS

   0install select [OPTIONS] URI
       Select a version of the program identified by URI, and compatible versions of all  of  its
       dependencies.  The  information  about available versions is downloaded if it's not yet in
       the cache.

       The URI can be an HTTP URL, such as `http://site/program.xml',  a  local  path  name  like
       `file:///path/to/program.xml', or an alias like `alias:prog'.

       For  HTTP  URLs,  the  remote  file  is a signed XML document. If the key is not known and
       trusted, you will be prompted to accept it first. Local feed files  are  not  signed  (any
       signature will be ignored). Aliases are created using 0alias(1).

       You  can  also  specify a local selections document, as created previously using the --xml
       option, rather than a feed. In that case, 0install  simply  uses  those  versions  without
       running the solver.

       After  selecting  (but not downloading) a set of versions, the selection is displayed in a
       human-readable format. Use --xml to get machine-readable output.

       If a set of versions cannot be selected using the cached information, 0install will  check
       for updates first.

       If  a  set of versions can be selected based on the currently-cached information, but that
       information is getting stale, 0install will immediately return the current  selection  and
       will  also start a background process to check for updates.  The `freshness' configuration
       setting controls when cached information is considered to be stale.

       Options for select:

       --before=VERSION
              Select a version earlier than VERSION (i.e. force the use of an old version of  the
              program).  You  can  only  restrict  the  version  of the program itself using this
              option, not the version of any dependencies.

       --command=COMMAND
              Some programs provide multiple commands. This selects which one  you  want.  Common
              values  are  `run'  (the  default),  `test'  (used by 0test) and `compile' (used by
              0compile). You can also use --command="" if you don't want to run any command  (for
              example, if the package contains data rather than a program).

       --message=MESSAGE
              If  we  show  a dialog box for the download, display MESSAGE to the user to explain
              why the download is needed.

       --not-before=VERSION
              The selected version must not be earlier than VERSION.  e.g. if  you  want  to  run
              version 2.0 or later, use --not-before=2.0.

       --refresh
              Download  a  fresh copy of all used feeds before selecting. Normally, cached copies
              will be used if available (checking for updates later, in the background).

       --source
              Select source code rather than a binary. This is used internally by `0compile'.

       --xml  Print the set of chosen implementations as an XML document to stdout. This  can  be
              used later with the `download' and `run' sub-commands.

       `select'  returns an exit status of zero if it selected a set of versions, and a status of
       1 if it could not find a consistent set.

   0install download [OPTIONS] URI
       This behaves similarly to `0install select', except that it also  downloads  the  selected
       versions  if  they are not already cached. Unlike `select', it does not print the selected
       versions by default.

       All options for `select' can also be used for `download'. In addition, these  options  are
       available:

       --show Print the selected versions in a human-readable format to stdout.

       `download'  returns  an  exit status of zero if it selected a suitable set of versions and
       they are now all downloaded and in the cache. It returns a status of 1 otherwise.

   0install run [OPTIONS] URI [ARGS]
       This behaves similarly to `0install download', except that it also runs the program  after
       ensuring it is in the cache.

       To avoid having to keep typing the full URI, use the 0alias(1) command to create shortcuts
       to run your programs.

       All options for `select' and `download' can also be used for  `run'.  In  addition,  these
       options are available:

       -m, --main=MAIN
              Run  the  specified executable instead of the default. If MAIN starts with '/' then
              the path is relative to the implementation's top-level directory, whereas otherwise
              it  is  relative to the directory containing the default MAIN program. For example,
              if the default MAIN is bin/svn then using --main=svnadmin will run .../bin/svnadmin
              instead.  This option has been largely superseded by the newer --command option.

       -w, --wrapper=WRAPPER
              Instead  of  executing the chosen program directly, run WRAPPER PROGRAM ARGS.  This
              is useful for running debuggers and tracing tools on the program  (rather  than  on
              0install!).  Note  that  the wrapper is executed in the environment selected by the
              program; hence, this mechanism cannot be used for  sandboxing.  See  the  DEBUGGING
              section below.

       `run'  returns an exit status of 1 if the download step failed. Otherwise, the exit status
       will be the exit status of the program being run.

   0install update [OPTIONS] URI
       Check for updates to the program and download them if found. This is similar  to  0install
       download  --refresh,  except  that  it  prints  information about whether any changes were
       found.

       The options are the same as for `select'.

   0install import FEED
       Import a feed from a local file, as if it had been downloaded from the network.   This  is
       useful  when  testing  a  feed  file, to avoid uploading it to a remote server in order to
       download it again. The file must have a trusted digital signature, as when  fetching  from
       the network.

       It  is  also  useful  when  installing a feed from a CD or similar. Note: to create a full
       bundle, for archiving or distribution on CD, see 0export(1).

   0install add-feed FEED
       Register an additional source of implementations (versions) of a program.

       For example, when you check out a developer version of a project, it may  contain  an  XML
       feed  file.  To  add this version to the list of available versions, use `add-feed' on the
       XML file. The file is not copied, so you don't need to re-add the feed  each  time  it  is
       updated.  You  will probably also want to set the `help_with_testing' configuration option
       to ensure that testing versions are selected by default.

       Note that if you just want to run the program, you can invoke 0install on  the  feed  file
       directly (without using `add-feed'). This will force the it to use that version, but won't
       affect what happens when you run it using the URI as normal. Use `add-feed' when you  want
       to  use the developer version even when using the URI, or if the program is a library (and
       thus referenced by URI by other programs).

   0install remove-feed [INTERFACE] FEED
       Un-register a feed, reversing the effect of `add-feed'. If INTERFACE  is  not  given,  you
       will be prompted to choose which INTERFACE to remove it from.

   0install list-feeds URI
       List all extra feeds added to URI using `add-feed'.

   0install list PATTERN
       List  all  known interface (program) URIs. If a search term is given, only URIs containing
       that string are shown (case insensitive).

   0install config [NAME [VALUE]]
       View or change configuration settings.

       With no arguments, `0install  config'  displays  all  configuration  settings.   With  one
       argument, it displays the current value of the named setting.  With two arguments, it sets
       the setting to the given value.

   0install digest DIRECTORY | ARCHIVE [EXTRACT]
       Calculate the secure hash of an implementation.  This  is  a  unique  "fingerprint"  of  a
       directory  and  all  the  files  and subdirectories it contains. When publishing a program
       using 0install, this value must be placed in the XML file.

       -m, --algorithm=HASH
              Select the secure hash function to be used. Supported  values  are  "sha1new"  (the
              default) or "sha256".

       If  an  archive  is  given then the hash is for the directory that would be created if the
       archive were unpacked (or the EXTRACT subdirectory of it, if one is specified).  See also:
       0store(1)'s manifest command.

   0install --version
       This can be used (without any command) the get version of 0install itself:

DEBUGGING TIPS

       To debug 0install itself, use the --verbose and --console options. For example:

       $ 0install -vvc run http://myprog

       To trace or debug programs run by 0install, use the --wrapper option.  For example, to run
       myprog --help, displaying all calls to open(2):

       $ 0install run --wrapper="strace -e open" http://myprog --help

       If your program is interpreted (e.g.  a  Python  program),  and  you  wish  to  debug  the
       interpreter running it, you can do it like this:

       $ 0install run --wrapper="gdb --args python" http://myprog --help

FILES

       Configuration files (see freedesktop.org basedir spec):

       ~/.config/0install.net/injector/global
              Global configuration settings.

       ~/.config/0install.net/injector/trustdb.xml
              List of trusted keys.

       ~/.config/0install.net/injector/feeds
              Per-feed information (e.g. time of last check).

       ~/.config/0install.net/injector/interfaces
              Per-interface  settings  (preferred  stability  and  any extra feeds that have been
              registered).

       Cached data (can be re-downloaded if lost):

       ~/.cache/0install.net/interfaces
              Downloaded cached feed files.

       ~/.cache/0install.net/implementations
              Downloaded cached implementations, indexed by manifest digest.

       See the 0store(1) man page for more information.

LICENSE

       Copyright (C) 2011 Thomas Leonard.

       You may redistribute copies of this program under the terms  of  the  GNU  Lesser  General
       Public License.

BUGS

       Please report bugs to the developer mailing list:

       http://0install.net/support.html

AUTHOR

       Zero  Install  was  created by Thomas Leonard, with help from many others. See the Git log
       for details.

SEE ALSO

       0alias(1), 0store(1), 0launch(1)

       The Zero Install web-site:

       http://0install.net