Now you can run tests with and without --flutter-repo with a prebuilt binary on
Linux.

Fixes #307

1) Moved basic utility code into base/ directory to make it clear which code
   doesn't depend on Flutter-specific knowldge.
2) Move the CommandRunner subclasses into a runner/ directory because these
   aren't commands themselves.

This patch improves the error message.

Fixes #468

Sample output:

```
Flutter
Repository: git@github.com:flutter/flutter.git
Branch: master
Revision: 7be58b1a (62 minutes ago)
```

Fixes #433

Example:
   cd flutter/examples/stocks
   flutter --engine-src-path /path/to/engine/src apk -o Stocks.apk -m apk/AndroidManifest.xml

This option just prints the current git revision.

Fixes #40

Previously, we assumed the first build configuration would have one. Now we
keep looking until we find one. Also, re-ordered the configurations so that
you'll get the Android one if you have both, which is probably what you would
expect.

Fixes #100

This document describes the workflow for contributing code to this repository.

This flag builds a local FLX file and pushes that to the device instead of
using an HTTP server.

remove an unused import

review comments

rename st --> stack

Fixes https://github.com/flutter/engine/issues/1613

The `run_mojo` command doesn't integrate with `FlutterCommand` and doesn't
understand how to download its toolchain components ahead of time. Eventually
we should teach `run_mojo` how to integrate with the `Toolchain` class, but
until then, we can fix the regression by eagerly setting
`ArtifactStore.packageRoot` again.

Fixes https://github.com/domokit/mojo/issues/475

We were checking for a pubspec.yaml too early.

A common use case for members of the Flutter team is to have a dependency
override for the flutter package that points back into the engine src tree.
We can use that override to automatically detect the engine src path, which
makes the command line shorter.

This patch makes `flutter start` work without a clone of the engine git
repository. Making this work pulled a relatively large refactor of how the
commands interact with application packages and devices. Now commands that want
to interact with application packages or devices inherit from a common base
class that holds stores of those objects as members.

In production, the commands download and connect to devices based on the build
configuration stored on the FlutterCommandRunner. In testing, these fields are
used to mock out the real application package and devices.

Expose the main entry point for the tools via the library lets us run the tools
from the Flutter package, which simplifies the setup for end developers because
they don't need to declare a dependency on sky_tools directly.

I'm trying to get a feel for the code by writing some simple cleanup patches.

Add listen command and basic test, and don’t do unnecessary repeated work when listening or poking the android server.

This makes the 'package-root' option universal for sky_tools and configures the
ArtifactStore with it statically at startup. The actual sky_engine revision
is computed on demand.

Refactor all the commands to be Commands from the Args package.  Also use CommandRunner for the top-level command.

This adds the following commands to sky_tools:
  sky_tools cache clear: Nukes all local artifacts in the cache
  sky_tools cache populate: Populates the cache with all known artifacts

This is useful both to fix busted caches and to make sure that the cache is
fully populated so that subsequent operations can proceed without needing
network access.

`dart bin/sky_tools.dart --debug --sky-src-path=/path/to/sky/src/ install` now works.

This initial version assumes the developer has mojo_shell and all other services
sitting on disk somewhere and that they're on linux and only want to run on
linux. This can be generalized down the line to support more use cases. This
downloads the sky_viewer.mojo corresponding to the packages/sky_engine/REVISION
in the developer's directory, so they can specify whatever revision they want.
sky_tools run_mojo downloads sky_viewer.mojo into its cache directory if it is
not present and constructs a command line to pass to mojo_shell that maps the
shebang stamped into the flx to the downloaded sky_viewer.mojo.

Since sky_viewer.mojo lives in the cloud and mojo_shell can load from the cloud
this could also map to an https URL. This should likely be an option.

This command will produce an flx package. Currently, this command doesn't work
because we don't have the Flutter compiler downloaded from Google storage yet.
A future patch will make that happen.

Add very-verbose flag and automatically log some more process-related things in verbose and very-verbose modes.