>>>
(the first line of each entry is the summary for autogenerated command lists)
Usage: meteor [--release <release>] [--help] <command> [args]
       meteor help <command>
       meteor [--version] [--arch]

With no arguments, 'meteor' runs the project in the current
directory in local development mode. You can run it from the root
directory of the project or from any subdirectory.

Use 'meteor create <name>' to create a new Meteor project.

Commands:
{{commands}}

See 'meteor help <command>' for details on a command.


>>> run
[default] Run this project in local development mode
Usage: meteor run [options]

Searches upward from the current directory for the root directory of a
Meteor project, then runs that project in local development
mode. You can use the application by pointing your web browser at
localhost:3000. No internet connection is required.

Whenever you change any of the application's source files, the changes
are automatically detected and applied to the running application.

The application's database persists between runs. It's stored under
the .meteor directory in the root of the project.

Options:
  --port, -p    Port to listen on (instead of the default 3000). Also
                uses port N+1 and a port specified by --app-port.
                Specify as --port=host:port to bind to a specific interface.
  --production  Simulate production mode. Minify and bundle CSS and JS files.
  --raw-logs    Run without parsing logs from stdout and stderr.
  --settings    Set optional data for Meteor.settings on the server
  --release     Specify the release of Meteor to use
  --program     The program in the app to run (Advanced)


>>> create
Create a new project
Usage: meteor create [--release <release>] <name>
       meteor create [--release <release>] --example <example_name> [<name>]
       meteor create --list

Make a subdirectory named <name> and create a new Meteor project
there. You can also pass an absolute or relative path.

The project will use the release of Meteor specified with the --release
option, or the latest available version if the option is not specified.

You can pass --example to start off with a copy of one of the Meteor
sample applications. Use --list to see the available examples.

Options:
  --example  Example template to use.
  --list     Show list of available examples.


>>> update
Upgrade this project to the latest version of Meteor
Usage: meteor update [--release <release>]

Sets the version of Meteor to use with the current project. If a
release is specified with --release, set the project to use that
version. Otherwise download and use the latest release of Meteor.


>>> run-upgrader
Execute a specific upgrader by name. Intended for testing.
Usage: meteor run-upgrader <upgrader>

Runs a specific upgrader on the current app. This is for testing
internal functionality of Meteor.


>>> add
Add a package to this project
Usage: meteor add <package> [package] [package..]

Adds packages to your Meteor project. You can add multiple
packages with one command. For a list of the available packages, see
'meteor list'.


>>> remove
Remove a package from this project
Usage: meteor remove <package> [package] [package..]

Removes a package previously added to your Meteor project. For a
list of the packages that your application is currently using, see
'meteor list --using'.


>>> list
List available packages
Usage: meteor list [--using]

Without arguments, lists all available Meteor packages. To add one
of these packages to your project, see 'meteor add'.

With --using, list the packages that you have added to your project.


>>> bundle
Pack this project up into a tarball
Usage: meteor bundle <output_file.tar.gz>

Package this project up for deployment. The output is a tarball that
includes everything necessary to run the application. See README in
the tarball for details.

Options:
  --debug      bundle in debug mode (don't minify, etc)
  --directory  output a directory (rather than a tarball). If the output
               location exists, it will be recursively deleted first.


>>> mongo
Connect to the Mongo database for the specified site
Usage: meteor mongo [--url] [site]

Opens a Mongo shell to view or manipulate collections.

If site is specified, this is the hosted Mongo database for the deployed
Meteor site.

If no site is specified, this is the current project's local development
database. In this case, the current working directory must be a
Meteor project directory, and the Meteor application must already be
running.

Instead of opening a shell, specifying --url (-U) will return a URL
suitable for an external program to connect to the database. For remote
databases on deployed applications, the URL is valid for one minute.

Options:
  --url, -U  return a Mongo database URL


>>> reset
Reset the project state. Erases the local database.
Usage: meteor reset

Reset the current project to a fresh state. Removes all local data.


>>> deploy
Deploy this project to Meteor
Usage: meteor deploy <site> [--settings settings.json] [--debug] [--delete]

Deploys the project in your current directory to Meteor's servers.

You can deploy to any available name under 'meteor.com'
without any additional configuration, for example,
'myapp.meteor.com'. If you deploy to a custom domain, such as
'myapp.mydomain.com', then you'll also need to configure your domain's
DNS records. See the Meteor docs for details.

The --settings flag can be used to pass deploy-specific information to
the application. It will be available at runtime in Meteor.settings, but only
on the server. If the object contains a key named 'public', then
Meteor.settings.public will also be available on the client. The argument
is the name of a file containing the JSON data to use. The settings will
persist across deployments until you again specify a settings file. To
unset Meteor.settings, pass an empty settings file.

The --delete flag permanently removes a deployed application, including
all of its stored data.

Options:
  --delete, -D  permanently delete this deployment
  --debug       deploy in debug mode (don't minify, etc)
  --settings    set optional data for Meteor.settings
  --star        a star (tarball) to deploy instead of the current Meteor app


>>> logs
Show logs for specified site
Usage: meteor logs <site>

Retrieves the server logs for the requested site.


>>> authorized
View or change authorized users for a site
Usage: meteor authorized <site> [--list]
       meteor authorized <site> --add <username>
       meteor authorized <site> --remove <username>

Without an argument (or with --list), list the users that are
administrators for a particular site that was deployed with 'meteor deploy'

With --add, add an authorized user to a site. Use this to give your
collaborators the ability to work with your sites.

With --remove, remove an authorized user from a site. You cannot remove
yourself. (Ask someone else who is an authorized user to do it.)

You can only add or remove one authorized user at a time.

Options:
  --add         add an authorized user
  --remove      remove an authorized user
  --list        list authorized users (the default)


>>> claim
Claim a site deployed with an old Meteor version
Usage: meteor claim <site>

If you deployed a site with an old version of Meteor that did not have
support for developer accounts, you can use this command to claim that
site into your account. If you had set a password on the site you will
be prompted for it one last time.


>>> login
Log in to your Meteor developer account
Usage: meteor login [--email]

Prompts for your username and password and logs you in to your Meteor
developer account. Pass --email to log in by email address rather than
by username.


>>> logout
Log out of your Meteor developer account
Usage: meteor logout

Log out of your Meteor developer account.


>>> whoami
Prints the username of your Meteor developer account
Usage: meteor whoami

Prints the username of the currently logged-in Meteor developer.

See 'meteor login' to log into or 'meteor logout' to log out of your
Meteor developer account.


>>> test-packages
Test one or more packages
Usage: meteor test-packages [--release <release>] [options] [package...]

Runs unit tests for one or more packages. The results are shown in
a browser dashboard that updates whenever a relevant source file is
modified.

Packages may be specified by name or by path. If a package argument
contains a '/', it is loaded from a directory of that name; otherwise,
the package name is resolved according to the usual package search
algorithm ('packages' subdirectory of the current app, $PACKAGE_DIRS
directories, and core packages in that order). You can test any number
of packages simultaneously. If you don't specify any package names
then all available packages will be tested.

Open the test dashboard in your browser to run the tests and see the
results. By default the URL is localhost:3000 but that can be changed
with --port. Alternatively, you can deploy the tests onto the 'meteor
deploy' server by using --deploy. This gives you a public URL that you
can use in conjunction with a service like Browserling or BrowserStack
to try the tests against many different browser versions.

Options:
  --port, -p    Port to listen on (instead of the default 3000). Also
                uses port N+1 and N+2.
  --deploy      Optionally, specify a domain to deploy to, rather than
                running locally.
  --production  Simulate production mode. Minify and bundle CSS and JS files.
  --settings    Set optional data for Meteor.settings on the server


>>> rebuild-all
Rebuild all packages
Usage: meteor rebuild-all

Rebuild all source packages in the library. This includes packages found
through the PACKAGE_DIRS environment variable, local packages in the
current application, and packages in the warehouse (but only those in the
currently effective Meteor release). It doesn't include any packages for
which we don't have the source.

You should never need to use this command. It is intended for use while
debugging the Meteor packaging tools themselves.


>>> run-command
Build and run a command-line tool
Usage: meteor run-command <package directory> [arguments..]

Builds the provided directory as a package, then loads the package and
calls the main() function inside the package. The function will receive
any remaining arguments. The exit status will be the return value of
main() (which is called inside a fiber).

The arguments will be parsed by Meteor's option parser, which means that
--release will be effective (but not passed to the command), and that it will be
an error to pass any unknown options. If you want to pass options to your tool,
place them after a '--' argument (which turns off option parsing for the rest of
the arguments).

This command is for temporary, internal use, until we have a more mature
system for building standalone command-line programs with Meteor.


>>> self-test
Run tests of the 'meteor' tool.
Usage: meteor self-test [pattern] [--changed] [--slow]
                        [--force-online] [--history n]

Runs internal tests. Exits with status 0 on success.

If 'pattern' is provided, it should be a regular expression. Only
tests that match the regular expression will be run.

Pass --changed to run only tests that have changed since they last
passed. This uses a really rough heuristic: A test has changed iff
there has been any change to the file in the 'selftests' subdirectory
that defines it. State for this is tracked in ~/.meteortest.

Some tests are really slow. Test flagged as slow won't be run unless
you pass --slow. Remember to do this from time to time!

Normally, this command detects whether you are offline and skips tests that
require network access automatically. If you want to try to run them anyway,
pass --force-online.

Use --history to change the number of lines of program output that are
shown on test failure. The default is 10.


>>> admin
Administrative commands
Usage: meteor admin <command> [args]
       meteor help admin <command>

Rarely used commands for administering official Meteor services.

Commands:
{{commands}}

See 'meteor help admin <command>' for details on an admin command.


>>> dummy
Dummy command used for automated testing
Usage: meteor dummy [options]

Dummy command used for automated testing.

Options:
  --email, -e  A required string option.
  --port, -p   A numeric option with a short alias.
  --changed    A boolean option.


>>> admin grant
Grant a permission on an official service
Usage: meteor admin grant [XXX]

Not yet implemented


>>> list-sites
List sites for which you are authorized.
Usage: meteor list-sites

List the sites that you have deployed with 'meteor deploy', and sites
for which other users have authorized you with the 'meteor authorized'
command.
