diff --git a/.gitmodules b/.gitmodules
deleted file mode 100644
index d83ab14..0000000
--- a/.gitmodules
+++ /dev/null
@@ -1,3 +0,0 @@
-[submodule "script/plugin_tools"]
-	path = script/plugin_tools
-	url = https://github.com/flutter/plugin_tools.git
diff --git a/script/common.sh b/script/common.sh
index 4c8aff9..28c3754 100644
--- a/script/common.sh
+++ b/script/common.sh
@@ -48,6 +48,6 @@
 
 # Runs the plugin tools from the plugin_tools git submodule.
 function plugin_tools() {
-  (pushd "$REPO_DIR/script/plugin_tools" && dart pub get && popd) >/dev/null
-  dart run "$REPO_DIR/script/plugin_tools/lib/src/main.dart" "$@"
+  (pushd "$REPO_DIR/script/tool" && dart pub get && popd) >/dev/null
+  dart run "$REPO_DIR/script/tool/lib/src/main.dart" "$@"
 }
diff --git a/script/plugin_tools b/script/plugin_tools
deleted file mode 160000
index 432c56d..0000000
--- a/script/plugin_tools
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 432c56da35880e95f6cbb02c40e9da0361771f48
diff --git a/script/tool/README.md b/script/tool/README.md
new file mode 100644
index 0000000..162ca0d
--- /dev/null
+++ b/script/tool/README.md
@@ -0,0 +1,8 @@
+# Flutter Plugin Tools
+
+To run the tool:
+
+```sh
+dart pub get
+dart run lib/src/main.dart <args>
+```
diff --git a/script/tool/lib/src/analyze_command.dart b/script/tool/lib/src/analyze_command.dart
new file mode 100644
index 0000000..8cd57fa
--- /dev/null
+++ b/script/tool/lib/src/analyze_command.dart
@@ -0,0 +1,94 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'dart:async';
+
+import 'package:file/file.dart';
+import 'package:path/path.dart' as p;
+
+import 'common.dart';
+
+class AnalyzeCommand extends PluginCommand {
+  AnalyzeCommand(
+    Directory packagesDir,
+    FileSystem fileSystem, {
+    ProcessRunner processRunner = const ProcessRunner(),
+  }) : super(packagesDir, fileSystem, processRunner: processRunner) {
+    argParser.addMultiOption(_customAnalysisFlag,
+        help:
+            'Directories (comma seperated) that are allowed to have their own analysis options.',
+        defaultsTo: <String>[]);
+  }
+
+  static const String _customAnalysisFlag = 'custom-analysis';
+
+  @override
+  final String name = 'analyze';
+
+  @override
+  final String description = 'Analyzes all packages using package:tuneup.\n\n'
+      'This command requires "pub" and "flutter" to be in your path.';
+
+  @override
+  Future<Null> run() async {
+    checkSharding();
+
+    print('Verifying analysis settings...');
+    final List<FileSystemEntity> files = packagesDir.listSync(recursive: true);
+    for (final FileSystemEntity file in files) {
+      if (file.basename != 'analysis_options.yaml' &&
+          file.basename != '.analysis_options') {
+        continue;
+      }
+
+      final bool whitelisted = argResults[_customAnalysisFlag].any(
+          (String directory) =>
+              p.isWithin(p.join(packagesDir.path, directory), file.path));
+      if (whitelisted) {
+        continue;
+      }
+
+      print('Found an extra analysis_options.yaml in ${file.absolute.path}.');
+      print(
+          'If this was deliberate, pass the package to the analyze command with the --$_customAnalysisFlag flag and try again.');
+      throw ToolExit(1);
+    }
+
+    print('Activating tuneup package...');
+    await processRunner.runAndStream(
+        'pub', <String>['global', 'activate', 'tuneup'],
+        workingDir: packagesDir, exitOnError: true);
+
+    await for (Directory package in getPackages()) {
+      if (isFlutterPackage(package, fileSystem)) {
+        await processRunner.runAndStream('flutter', <String>['packages', 'get'],
+            workingDir: package, exitOnError: true);
+      } else {
+        await processRunner.runAndStream('pub', <String>['get'],
+            workingDir: package, exitOnError: true);
+      }
+    }
+
+    final List<String> failingPackages = <String>[];
+    await for (Directory package in getPlugins()) {
+      final int exitCode = await processRunner.runAndStream(
+          'pub', <String>['global', 'run', 'tuneup', 'check'],
+          workingDir: package);
+      if (exitCode != 0) {
+        failingPackages.add(p.basename(package.path));
+      }
+    }
+
+    print('\n\n');
+    if (failingPackages.isNotEmpty) {
+      print('The following packages have analyzer errors (see above):');
+      failingPackages.forEach((String package) {
+        print(' * $package');
+      });
+      throw ToolExit(1);
+    }
+
+    print('No analyzer errors found!');
+  }
+}
diff --git a/script/tool/lib/src/build_examples_command.dart b/script/tool/lib/src/build_examples_command.dart
new file mode 100644
index 0000000..53da908
--- /dev/null
+++ b/script/tool/lib/src/build_examples_command.dart
@@ -0,0 +1,188 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'dart:async';
+import 'dart:io' as io;
+
+import 'package:file/file.dart';
+import 'package:path/path.dart' as p;
+import 'package:platform/platform.dart';
+
+import 'common.dart';
+
+class BuildExamplesCommand extends PluginCommand {
+  BuildExamplesCommand(
+    Directory packagesDir,
+    FileSystem fileSystem, {
+    ProcessRunner processRunner = const ProcessRunner(),
+  }) : super(packagesDir, fileSystem, processRunner: processRunner) {
+    argParser.addFlag(kLinux, defaultsTo: false);
+    argParser.addFlag(kMacos, defaultsTo: false);
+    argParser.addFlag(kWindows, defaultsTo: false);
+    argParser.addFlag(kIpa, defaultsTo: io.Platform.isMacOS);
+    argParser.addFlag(kApk);
+    argParser.addOption(
+      kEnableExperiment,
+      defaultsTo: '',
+      help: 'Enables the given Dart SDK experiments.',
+    );
+  }
+
+  @override
+  final String name = 'build-examples';
+
+  @override
+  final String description =
+      'Builds all example apps (IPA for iOS and APK for Android).\n\n'
+      'This command requires "flutter" to be in your path.';
+
+  @override
+  Future<Null> run() async {
+    if (!argResults[kIpa] &&
+        !argResults[kApk] &&
+        !argResults[kLinux] &&
+        !argResults[kMacos] &&
+        !argResults[kWindows]) {
+      print(
+          'None of --linux, --macos, --windows, --apk nor --ipa were specified, '
+          'so not building anything.');
+      return;
+    }
+    final String flutterCommand =
+        LocalPlatform().isWindows ? 'flutter.bat' : 'flutter';
+
+    final String enableExperiment = argResults[kEnableExperiment];
+
+    checkSharding();
+    final List<String> failingPackages = <String>[];
+    await for (Directory plugin in getPlugins()) {
+      for (Directory example in getExamplesForPlugin(plugin)) {
+        final String packageName =
+            p.relative(example.path, from: packagesDir.path);
+
+        if (argResults[kLinux]) {
+          print('\nBUILDING Linux for $packageName');
+          if (isLinuxPlugin(plugin, fileSystem)) {
+            int buildExitCode = await processRunner.runAndStream(
+                flutterCommand,
+                <String>[
+                  'build',
+                  kLinux,
+                  if (enableExperiment.isNotEmpty)
+                    '--enable-experiment=$enableExperiment',
+                ],
+                workingDir: example);
+            if (buildExitCode != 0) {
+              failingPackages.add('$packageName (linux)');
+            }
+          } else {
+            print('Linux is not supported by this plugin');
+          }
+        }
+
+        if (argResults[kMacos]) {
+          print('\nBUILDING macOS for $packageName');
+          if (isMacOsPlugin(plugin, fileSystem)) {
+            // TODO(https://github.com/flutter/flutter/issues/46236):
+            // Builing macos without running flutter pub get first results
+            // in an error.
+            int exitCode = await processRunner.runAndStream(
+                flutterCommand, <String>['pub', 'get'],
+                workingDir: example);
+            if (exitCode != 0) {
+              failingPackages.add('$packageName (macos)');
+            } else {
+              exitCode = await processRunner.runAndStream(
+                  flutterCommand,
+                  <String>[
+                    'build',
+                    kMacos,
+                    if (enableExperiment.isNotEmpty)
+                      '--enable-experiment=$enableExperiment',
+                  ],
+                  workingDir: example);
+              if (exitCode != 0) {
+                failingPackages.add('$packageName (macos)');
+              }
+            }
+          } else {
+            print('macOS is not supported by this plugin');
+          }
+        }
+
+        if (argResults[kWindows]) {
+          print('\nBUILDING Windows for $packageName');
+          if (isWindowsPlugin(plugin, fileSystem)) {
+            int buildExitCode = await processRunner.runAndStream(
+                flutterCommand,
+                <String>[
+                  'build',
+                  kWindows,
+                  if (enableExperiment.isNotEmpty)
+                    '--enable-experiment=$enableExperiment',
+                ],
+                workingDir: example);
+            if (buildExitCode != 0) {
+              failingPackages.add('$packageName (windows)');
+            }
+          } else {
+            print('Windows is not supported by this plugin');
+          }
+        }
+
+        if (argResults[kIpa]) {
+          print('\nBUILDING IPA for $packageName');
+          if (isIosPlugin(plugin, fileSystem)) {
+            final int exitCode = await processRunner.runAndStream(
+                flutterCommand,
+                <String>[
+                  'build',
+                  'ios',
+                  '--no-codesign',
+                  if (enableExperiment.isNotEmpty)
+                    '--enable-experiment=$enableExperiment',
+                ],
+                workingDir: example);
+            if (exitCode != 0) {
+              failingPackages.add('$packageName (ipa)');
+            }
+          } else {
+            print('iOS is not supported by this plugin');
+          }
+        }
+
+        if (argResults[kApk]) {
+          print('\nBUILDING APK for $packageName');
+          if (isAndroidPlugin(plugin, fileSystem)) {
+            final int exitCode = await processRunner.runAndStream(
+                flutterCommand,
+                <String>[
+                  'build',
+                  'apk',
+                  if (enableExperiment.isNotEmpty)
+                    '--enable-experiment=$enableExperiment',
+                ],
+                workingDir: example);
+            if (exitCode != 0) {
+              failingPackages.add('$packageName (apk)');
+            }
+          } else {
+            print('Android is not supported by this plugin');
+          }
+        }
+      }
+    }
+    print('\n\n');
+
+    if (failingPackages.isNotEmpty) {
+      print('The following build are failing (see above for details):');
+      for (String package in failingPackages) {
+        print(' * $package');
+      }
+      throw ToolExit(1);
+    }
+
+    print('All builds successful!');
+  }
+}
diff --git a/script/tool/lib/src/common.dart b/script/tool/lib/src/common.dart
new file mode 100644
index 0000000..78b91ee
--- /dev/null
+++ b/script/tool/lib/src/common.dart
@@ -0,0 +1,466 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'dart:async';
+import 'dart:io' as io;
+import 'dart:math';
+
+import 'package:args/command_runner.dart';
+import 'package:file/file.dart';
+import 'package:path/path.dart' as p;
+import 'package:yaml/yaml.dart';
+
+typedef void Print(Object object);
+
+/// Key for windows platform.
+const String kWindows = 'windows';
+
+/// Key for macos platform.
+const String kMacos = 'macos';
+
+/// Key for linux platform.
+const String kLinux = 'linux';
+
+/// Key for IPA (iOS) platform.
+const String kIos = 'ios';
+
+/// Key for APK (Android) platform.
+const String kAndroid = 'android';
+
+/// Key for Web platform.
+const String kWeb = 'web';
+
+/// Key for IPA.
+const String kIpa = 'ipa';
+
+/// Key for APK.
+const String kApk = 'apk';
+
+/// Key for enable experiment.
+const String kEnableExperiment = 'enable-experiment';
+
+/// Returns whether the given directory contains a Flutter package.
+bool isFlutterPackage(FileSystemEntity entity, FileSystem fileSystem) {
+  if (entity == null || entity is! Directory) {
+    return false;
+  }
+
+  try {
+    final File pubspecFile =
+        fileSystem.file(p.join(entity.path, 'pubspec.yaml'));
+    final YamlMap pubspecYaml = loadYaml(pubspecFile.readAsStringSync());
+    final YamlMap dependencies = pubspecYaml['dependencies'];
+    if (dependencies == null) {
+      return false;
+    }
+    return dependencies.containsKey('flutter');
+  } on FileSystemException {
+    return false;
+  } on YamlException {
+    return false;
+  }
+}
+
+/// Returns whether the given directory contains a Flutter [platform] plugin.
+///
+/// It checks this by looking for the following pattern in the pubspec:
+///
+///     flutter:
+///       plugin:
+///         platforms:
+///           [platform]:
+bool pluginSupportsPlatform(
+    String platform, FileSystemEntity entity, FileSystem fileSystem) {
+  assert(platform == kIos ||
+      platform == kAndroid ||
+      platform == kWeb ||
+      platform == kMacos ||
+      platform == kWindows ||
+      platform == kLinux);
+  if (entity == null || entity is! Directory) {
+    return false;
+  }
+
+  try {
+    final File pubspecFile =
+        fileSystem.file(p.join(entity.path, 'pubspec.yaml'));
+    final YamlMap pubspecYaml = loadYaml(pubspecFile.readAsStringSync());
+    final YamlMap flutterSection = pubspecYaml['flutter'];
+    if (flutterSection == null) {
+      return false;
+    }
+    final YamlMap pluginSection = flutterSection['plugin'];
+    if (pluginSection == null) {
+      return false;
+    }
+    final YamlMap platforms = pluginSection['platforms'];
+    if (platforms == null) {
+      // Legacy plugin specs are assumed to support iOS and Android.
+      if (!pluginSection.containsKey('platforms')) {
+        return platform == kIos || platform == kAndroid;
+      }
+      return false;
+    }
+    return platforms.containsKey(platform);
+  } on FileSystemException {
+    return false;
+  } on YamlException {
+    return false;
+  }
+}
+
+/// Returns whether the given directory contains a Flutter Android plugin.
+bool isAndroidPlugin(FileSystemEntity entity, FileSystem fileSystem) {
+  return pluginSupportsPlatform(kAndroid, entity, fileSystem);
+}
+
+/// Returns whether the given directory contains a Flutter iOS plugin.
+bool isIosPlugin(FileSystemEntity entity, FileSystem fileSystem) {
+  return pluginSupportsPlatform(kIos, entity, fileSystem);
+}
+
+/// Returns whether the given directory contains a Flutter web plugin.
+bool isWebPlugin(FileSystemEntity entity, FileSystem fileSystem) {
+  return pluginSupportsPlatform(kWeb, entity, fileSystem);
+}
+
+/// Returns whether the given directory contains a Flutter Windows plugin.
+bool isWindowsPlugin(FileSystemEntity entity, FileSystem fileSystem) {
+  return pluginSupportsPlatform(kWindows, entity, fileSystem);
+}
+
+/// Returns whether the given directory contains a Flutter macOS plugin.
+bool isMacOsPlugin(FileSystemEntity entity, FileSystem fileSystem) {
+  return pluginSupportsPlatform(kMacos, entity, fileSystem);
+}
+
+/// Returns whether the given directory contains a Flutter linux plugin.
+bool isLinuxPlugin(FileSystemEntity entity, FileSystem fileSystem) {
+  return pluginSupportsPlatform(kLinux, entity, fileSystem);
+}
+
+/// Error thrown when a command needs to exit with a non-zero exit code.
+class ToolExit extends Error {
+  ToolExit(this.exitCode);
+
+  final int exitCode;
+}
+
+abstract class PluginCommand extends Command<Null> {
+  PluginCommand(
+    this.packagesDir,
+    this.fileSystem, {
+    this.processRunner = const ProcessRunner(),
+  }) {
+    argParser.addMultiOption(
+      _pluginsArg,
+      splitCommas: true,
+      help:
+          'Specifies which plugins the command should run on (before sharding).',
+      valueHelp: 'plugin1,plugin2,...',
+    );
+    argParser.addOption(
+      _shardIndexArg,
+      help: 'Specifies the zero-based index of the shard to '
+          'which the command applies.',
+      valueHelp: 'i',
+      defaultsTo: '0',
+    );
+    argParser.addOption(
+      _shardCountArg,
+      help: 'Specifies the number of shards into which plugins are divided.',
+      valueHelp: 'n',
+      defaultsTo: '1',
+    );
+    argParser.addMultiOption(
+      _excludeArg,
+      abbr: 'e',
+      help: 'Exclude packages from this command.',
+      defaultsTo: <String>[],
+    );
+  }
+
+  static const String _pluginsArg = 'plugins';
+  static const String _shardIndexArg = 'shardIndex';
+  static const String _shardCountArg = 'shardCount';
+  static const String _excludeArg = 'exclude';
+
+  /// The directory containing the plugin packages.
+  final Directory packagesDir;
+
+  /// The file system.
+  ///
+  /// This can be overridden for testing.
+  final FileSystem fileSystem;
+
+  /// The process runner.
+  ///
+  /// This can be overridden for testing.
+  final ProcessRunner processRunner;
+
+  int _shardIndex;
+  int _shardCount;
+
+  int get shardIndex {
+    if (_shardIndex == null) {
+      checkSharding();
+    }
+    return _shardIndex;
+  }
+
+  int get shardCount {
+    if (_shardCount == null) {
+      checkSharding();
+    }
+    return _shardCount;
+  }
+
+  void checkSharding() {
+    final int shardIndex = int.tryParse(argResults[_shardIndexArg]);
+    final int shardCount = int.tryParse(argResults[_shardCountArg]);
+    if (shardIndex == null) {
+      usageException('$_shardIndexArg must be an integer');
+    }
+    if (shardCount == null) {
+      usageException('$_shardCountArg must be an integer');
+    }
+    if (shardCount < 1) {
+      usageException('$_shardCountArg must be positive');
+    }
+    if (shardIndex < 0 || shardCount <= shardIndex) {
+      usageException(
+          '$_shardIndexArg must be in the half-open range [0..$shardCount[');
+    }
+    _shardIndex = shardIndex;
+    _shardCount = shardCount;
+  }
+
+  /// Returns the root Dart package folders of the plugins involved in this
+  /// command execution.
+  Stream<Directory> getPlugins() async* {
+    // To avoid assuming consistency of `Directory.list` across command
+    // invocations, we collect and sort the plugin folders before sharding.
+    // This is considered an implementation detail which is why the API still
+    // uses streams.
+    final List<Directory> allPlugins = await _getAllPlugins().toList();
+    allPlugins.sort((Directory d1, Directory d2) => d1.path.compareTo(d2.path));
+    // Sharding 10 elements into 3 shards should yield shard sizes 4, 4, 2.
+    // Sharding  9 elements into 3 shards should yield shard sizes 3, 3, 3.
+    // Sharding  2 elements into 3 shards should yield shard sizes 1, 1, 0.
+    final int shardSize = allPlugins.length ~/ shardCount +
+        (allPlugins.length % shardCount == 0 ? 0 : 1);
+    final int start = min(shardIndex * shardSize, allPlugins.length);
+    final int end = min(start + shardSize, allPlugins.length);
+
+    for (Directory plugin in allPlugins.sublist(start, end)) {
+      yield plugin;
+    }
+  }
+
+  /// Returns the root Dart package folders of the plugins involved in this
+  /// command execution, assuming there is only one shard.
+  ///
+  /// Plugin packages can exist in one of two places relative to the packages
+  /// directory.
+  ///
+  /// 1. As a Dart package in a directory which is a direct child of the
+  ///    packages directory. This is a plugin where all of the implementations
+  ///    exist in a single Dart package.
+  /// 2. Several plugin packages may live in a directory which is a direct
+  ///    child of the packages directory. This directory groups several Dart
+  ///    packages which implement a single plugin. This directory contains a
+  ///    "client library" package, which declares the API for the plugin, as
+  ///    well as one or more platform-specific implementations.
+  Stream<Directory> _getAllPlugins() async* {
+    final Set<String> plugins = Set<String>.from(argResults[_pluginsArg]);
+    final Set<String> excludedPlugins =
+        Set<String>.from(argResults[_excludeArg]);
+
+    await for (FileSystemEntity entity
+        in packagesDir.list(followLinks: false)) {
+      // A top-level Dart package is a plugin package.
+      if (_isDartPackage(entity)) {
+        if (!excludedPlugins.contains(entity.basename) &&
+            (plugins.isEmpty || plugins.contains(p.basename(entity.path)))) {
+          yield entity;
+        }
+      } else if (entity is Directory) {
+        // Look for Dart packages under this top-level directory.
+        await for (FileSystemEntity subdir in entity.list(followLinks: false)) {
+          if (_isDartPackage(subdir)) {
+            // If --plugin=my_plugin is passed, then match all federated
+            // plugins under 'my_plugin'. Also match if the exact plugin is
+            // passed.
+            final String relativePath =
+                p.relative(subdir.path, from: packagesDir.path);
+            final String basenamePath = p.basename(entity.path);
+            if (!excludedPlugins.contains(basenamePath) &&
+                !excludedPlugins.contains(relativePath) &&
+                (plugins.isEmpty ||
+                    plugins.contains(relativePath) ||
+                    plugins.contains(basenamePath))) {
+              yield subdir;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  /// Returns the example Dart package folders of the plugins involved in this
+  /// command execution.
+  Stream<Directory> getExamples() =>
+      getPlugins().expand<Directory>(getExamplesForPlugin);
+
+  /// Returns all Dart package folders (typically, plugin + example) of the
+  /// plugins involved in this command execution.
+  Stream<Directory> getPackages() async* {
+    await for (Directory plugin in getPlugins()) {
+      yield plugin;
+      yield* plugin
+          .list(recursive: true, followLinks: false)
+          .where(_isDartPackage)
+          .cast<Directory>();
+    }
+  }
+
+  /// Returns the files contained, recursively, within the plugins
+  /// involved in this command execution.
+  Stream<File> getFiles() {
+    return getPlugins().asyncExpand<File>((Directory folder) => folder
+        .list(recursive: true, followLinks: false)
+        .where((FileSystemEntity entity) => entity is File)
+        .cast<File>());
+  }
+
+  /// Returns whether the specified entity is a directory containing a
+  /// `pubspec.yaml` file.
+  bool _isDartPackage(FileSystemEntity entity) {
+    return entity is Directory &&
+        fileSystem.file(p.join(entity.path, 'pubspec.yaml')).existsSync();
+  }
+
+  /// Returns the example Dart packages contained in the specified plugin, or
+  /// an empty List, if the plugin has no examples.
+  Iterable<Directory> getExamplesForPlugin(Directory plugin) {
+    final Directory exampleFolder =
+        fileSystem.directory(p.join(plugin.path, 'example'));
+    if (!exampleFolder.existsSync()) {
+      return <Directory>[];
+    }
+    if (isFlutterPackage(exampleFolder, fileSystem)) {
+      return <Directory>[exampleFolder];
+    }
+    // Only look at the subdirectories of the example directory if the example
+    // directory itself is not a Dart package, and only look one level below the
+    // example directory for other dart packages.
+    return exampleFolder
+        .listSync()
+        .where(
+            (FileSystemEntity entity) => isFlutterPackage(entity, fileSystem))
+        .cast<Directory>();
+  }
+}
+
+/// A class used to run processes.
+///
+/// We use this instead of directly running the process so it can be overridden
+/// in tests.
+class ProcessRunner {
+  const ProcessRunner();
+
+  /// Run the [executable] with [args] and stream output to stderr and stdout.
+  ///
+  /// The current working directory of [executable] can be overridden by
+  /// passing [workingDir].
+  ///
+  /// If [exitOnError] is set to `true`, then this will throw an error if
+  /// the [executable] terminates with a non-zero exit code.
+  ///
+  /// Returns the exit code of the [executable].
+  Future<int> runAndStream(
+    String executable,
+    List<String> args, {
+    Directory workingDir,
+    bool exitOnError = false,
+  }) async {
+    print(
+        'Running command: "$executable ${args.join(' ')}" in ${workingDir?.path ?? io.Directory.current.path}');
+    final io.Process process = await io.Process.start(executable, args,
+        workingDirectory: workingDir?.path);
+    await io.stdout.addStream(process.stdout);
+    await io.stderr.addStream(process.stderr);
+    if (exitOnError && await process.exitCode != 0) {
+      final String error =
+          _getErrorString(executable, args, workingDir: workingDir);
+      print('$error See above for details.');
+      throw ToolExit(await process.exitCode);
+    }
+    return process.exitCode;
+  }
+
+  /// Run the [executable] with [args].
+  ///
+  /// The current working directory of [executable] can be overridden by
+  /// passing [workingDir].
+  ///
+  /// If [exitOnError] is set to `true`, then this will throw an error if
+  /// the [executable] terminates with a non-zero exit code.
+  ///
+  /// Returns the [io.ProcessResult] of the [executable].
+  Future<io.ProcessResult> run(String executable, List<String> args,
+      {Directory workingDir,
+      bool exitOnError = false,
+      stdoutEncoding = io.systemEncoding,
+      stderrEncoding = io.systemEncoding}) async {
+    return io.Process.run(executable, args,
+        workingDirectory: workingDir?.path,
+        stdoutEncoding: stdoutEncoding,
+        stderrEncoding: stderrEncoding);
+  }
+
+  /// Starts the [executable] with [args].
+  ///
+  /// The current working directory of [executable] can be overridden by
+  /// passing [workingDir].
+  ///
+  /// Returns the started [io.Process].
+  Future<io.Process> start(String executable, List<String> args,
+      {Directory workingDirectory}) async {
+    final io.Process process = await io.Process.start(executable, args,
+        workingDirectory: workingDirectory?.path);
+    return process;
+  }
+
+  /// Run the [executable] with [args], throwing an error on non-zero exit code.
+  ///
+  /// Unlike [runAndStream], this does not stream the process output to stdout.
+  /// It also unconditionally throws an error on a non-zero exit code.
+  ///
+  /// The current working directory of [executable] can be overridden by
+  /// passing [workingDir].
+  ///
+  /// Returns the [io.ProcessResult] of running the [executable].
+  Future<io.ProcessResult> runAndExitOnError(
+    String executable,
+    List<String> args, {
+    Directory workingDir,
+  }) async {
+    final io.ProcessResult result = await io.Process.run(executable, args,
+        workingDirectory: workingDir?.path);
+    if (result.exitCode != 0) {
+      final String error =
+          _getErrorString(executable, args, workingDir: workingDir);
+      print('$error Stderr:\n${result.stdout}');
+      throw ToolExit(result.exitCode);
+    }
+    return result;
+  }
+
+  String _getErrorString(String executable, List<String> args,
+      {Directory workingDir}) {
+    final String workdir = workingDir == null ? '' : ' in ${workingDir.path}';
+    return 'ERROR: Unable to execute "$executable ${args.join(' ')}"$workdir.';
+  }
+}
diff --git a/script/tool/lib/src/create_all_plugins_app_command.dart b/script/tool/lib/src/create_all_plugins_app_command.dart
new file mode 100644
index 0000000..0f1431c
--- /dev/null
+++ b/script/tool/lib/src/create_all_plugins_app_command.dart
@@ -0,0 +1,200 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'dart:async';
+import 'dart:io' as io;
+
+import 'package:file/file.dart';
+import 'package:path/path.dart' as p;
+import 'package:pub_semver/pub_semver.dart';
+import 'package:pubspec_parse/pubspec_parse.dart';
+
+import 'common.dart';
+
+// TODO(cyanglaz): Add tests for this command.
+// https://github.com/flutter/flutter/issues/61049
+class CreateAllPluginsAppCommand extends PluginCommand {
+  CreateAllPluginsAppCommand(Directory packagesDir, FileSystem fileSystem)
+      : super(packagesDir, fileSystem);
+
+  @override
+  String get description =>
+      'Generate Flutter app that includes all plugins in packages.';
+
+  @override
+  String get name => 'all-plugins-app';
+
+  @override
+  Future<Null> run() async {
+    final int exitCode = await _createPlugin();
+    if (exitCode != 0) {
+      throw ToolExit(exitCode);
+    }
+
+    await Future.wait(<Future<void>>[
+      _genPubspecWithAllPlugins(),
+      _updateAppGradle(),
+      _updateManifest(),
+    ]);
+  }
+
+  Future<int> _createPlugin() async {
+    final io.ProcessResult result = io.Process.runSync(
+      'flutter',
+      <String>[
+        'create',
+        '--template=app',
+        '--project-name=all_plugins',
+        '--android-language=java',
+        './all_plugins',
+      ],
+    );
+
+    print(result.stdout);
+    print(result.stderr);
+    return result.exitCode;
+  }
+
+  Future<void> _updateAppGradle() async {
+    final File gradleFile = fileSystem.file(p.join(
+      'all_plugins',
+      'android',
+      'app',
+      'build.gradle',
+    ));
+    if (!gradleFile.existsSync()) {
+      throw ToolExit(64);
+    }
+
+    final StringBuffer newGradle = StringBuffer();
+    for (String line in gradleFile.readAsLinesSync()) {
+      newGradle.writeln(line);
+      if (line.contains('defaultConfig {')) {
+        newGradle.writeln('        multiDexEnabled true');
+      } else if (line.contains('dependencies {')) {
+        newGradle.writeln(
+          '    implementation \'com.google.guava:guava:27.0.1-android\'\n',
+        );
+        // Tests for https://github.com/flutter/flutter/issues/43383
+        newGradle.writeln(
+          "    implementation 'androidx.lifecycle:lifecycle-runtime:2.2.0-rc01'\n",
+        );
+      }
+    }
+    gradleFile.writeAsStringSync(newGradle.toString());
+  }
+
+  Future<void> _updateManifest() async {
+    final File manifestFile = fileSystem.file(p.join(
+      'all_plugins',
+      'android',
+      'app',
+      'src',
+      'main',
+      'AndroidManifest.xml',
+    ));
+    if (!manifestFile.existsSync()) {
+      throw ToolExit(64);
+    }
+
+    final StringBuffer newManifest = StringBuffer();
+    for (String line in manifestFile.readAsLinesSync()) {
+      if (line.contains('package="com.example.all_plugins"')) {
+        newManifest
+          ..writeln('package="com.example.all_plugins"')
+          ..writeln('xmlns:tools="http://schemas.android.com/tools">')
+          ..writeln()
+          ..writeln(
+            '<uses-sdk tools:overrideLibrary="io.flutter.plugins.camera"/>',
+          );
+      } else {
+        newManifest.writeln(line);
+      }
+    }
+    manifestFile.writeAsStringSync(newManifest.toString());
+  }
+
+  Future<void> _genPubspecWithAllPlugins() async {
+    final Map<String, PathDependency> pluginDeps =
+        await _getValidPathDependencies();
+    final Pubspec pubspec = Pubspec(
+      'all_plugins',
+      description: 'Flutter app containing all 1st party plugins.',
+      version: Version.parse('1.0.0+1'),
+      environment: <String, VersionConstraint>{
+        'sdk': VersionConstraint.compatibleWith(
+          Version.parse('2.0.0'),
+        ),
+      },
+      dependencies: <String, Dependency>{
+        'flutter': SdkDependency('flutter'),
+      }..addAll(pluginDeps),
+      devDependencies: <String, Dependency>{
+        'flutter_test': SdkDependency('flutter'),
+      },
+      dependencyOverrides: pluginDeps,
+    );
+    final File pubspecFile =
+        fileSystem.file(p.join('all_plugins', 'pubspec.yaml'));
+    pubspecFile.writeAsStringSync(_pubspecToString(pubspec));
+  }
+
+  Future<Map<String, PathDependency>> _getValidPathDependencies() async {
+    final Map<String, PathDependency> pathDependencies =
+        <String, PathDependency>{};
+
+    await for (Directory package in getPlugins()) {
+      final String pluginName = package.path.split('/').last;
+      final File pubspecFile =
+          fileSystem.file(p.join(package.path, 'pubspec.yaml'));
+      final Pubspec pubspec = Pubspec.parse(pubspecFile.readAsStringSync());
+
+      if (pubspec.publishTo != 'none') {
+        pathDependencies[pluginName] = PathDependency(package.path);
+      }
+    }
+    return pathDependencies;
+  }
+
+  String _pubspecToString(Pubspec pubspec) {
+    return '''
+### Generated file. Do not edit. Run `pub global run flutter_plugin_tools gen-pubspec` to update.
+name: ${pubspec.name}
+description: ${pubspec.description}
+
+version: ${pubspec.version}
+
+environment:${_pubspecMapString(pubspec.environment)}
+
+dependencies:${_pubspecMapString(pubspec.dependencies)}
+
+dependency_overrides:${_pubspecMapString(pubspec.dependencyOverrides)}
+
+dev_dependencies:${_pubspecMapString(pubspec.devDependencies)}
+###''';
+  }
+
+  String _pubspecMapString(Map<String, dynamic> values) {
+    final StringBuffer buffer = StringBuffer();
+
+    for (MapEntry<String, dynamic> entry in values.entries) {
+      buffer.writeln();
+      if (entry.value is VersionConstraint) {
+        buffer.write('  ${entry.key}: ${entry.value}');
+      } else if (entry.value is SdkDependency) {
+        final SdkDependency dep = entry.value;
+        buffer.write('  ${entry.key}: \n    sdk: ${dep.sdk}');
+      } else if (entry.value is PathDependency) {
+        final PathDependency dep = entry.value;
+        buffer.write('  ${entry.key}: \n    path: ${dep.path}');
+      } else {
+        throw UnimplementedError(
+          'Not available for type: ${entry.value.runtimeType}',
+        );
+      }
+    }
+
+    return buffer.toString();
+  }
+}
diff --git a/script/tool/lib/src/drive_examples_command.dart b/script/tool/lib/src/drive_examples_command.dart
new file mode 100644
index 0000000..59c6422
--- /dev/null
+++ b/script/tool/lib/src/drive_examples_command.dart
@@ -0,0 +1,210 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'dart:async';
+import 'package:file/file.dart';
+import 'package:path/path.dart' as p;
+import 'package:platform/platform.dart';
+import 'common.dart';
+
+class DriveExamplesCommand extends PluginCommand {
+  DriveExamplesCommand(
+    Directory packagesDir,
+    FileSystem fileSystem, {
+    ProcessRunner processRunner = const ProcessRunner(),
+  }) : super(packagesDir, fileSystem, processRunner: processRunner) {
+    argParser.addFlag(kLinux,
+        help: 'Runs the Linux implementation of the examples');
+    argParser.addFlag(kMacos,
+        help: 'Runs the macOS implementation of the examples');
+    argParser.addFlag(kWindows,
+        help: 'Runs the Windows implementation of the examples');
+    argParser.addFlag(kIos,
+        help: 'Runs the iOS implementation of the examples');
+    argParser.addFlag(kAndroid,
+        help: 'Runs the Android implementation of the examples');
+    argParser.addOption(
+      kEnableExperiment,
+      defaultsTo: '',
+      help:
+          'Runs the driver tests in Dart VM with the given experiments enabled.',
+    );
+  }
+
+  @override
+  final String name = 'drive-examples';
+
+  @override
+  final String description = 'Runs driver tests for plugin example apps.\n\n'
+      'For each *_test.dart in test_driver/ it drives an application with a '
+      'corresponding name in the test/ or test_driver/ directories.\n\n'
+      'For example, test_driver/app_test.dart would match test/app.dart.\n\n'
+      'This command requires "flutter" to be in your path.\n\n'
+      'If a file with a corresponding name cannot be found, this driver file'
+      'will be used to drive the tests that match '
+      'integration_test/*_test.dart.';
+
+  @override
+  Future<Null> run() async {
+    checkSharding();
+    final List<String> failingTests = <String>[];
+    final bool isLinux = argResults[kLinux];
+    final bool isMacos = argResults[kMacos];
+    final bool isWindows = argResults[kWindows];
+    await for (Directory plugin in getPlugins()) {
+      final String flutterCommand =
+          LocalPlatform().isWindows ? 'flutter.bat' : 'flutter';
+      for (Directory example in getExamplesForPlugin(plugin)) {
+        final String packageName =
+            p.relative(example.path, from: packagesDir.path);
+        if (!(await pluginSupportedOnCurrentPlatform(plugin, fileSystem))) {
+          continue;
+        }
+        final Directory driverTests =
+            fileSystem.directory(p.join(example.path, 'test_driver'));
+        if (!driverTests.existsSync()) {
+          // No driver tests available for this example
+          continue;
+        }
+        // Look for driver tests ending in _test.dart in test_driver/
+        await for (FileSystemEntity test in driverTests.list()) {
+          final String driverTestName =
+              p.relative(test.path, from: driverTests.path);
+          if (!driverTestName.endsWith('_test.dart')) {
+            continue;
+          }
+          // Try to find a matching app to drive without the _test.dart
+          final String deviceTestName = driverTestName.replaceAll(
+            RegExp(r'_test.dart$'),
+            '.dart',
+          );
+          String deviceTestPath = p.join('test', deviceTestName);
+          if (!fileSystem
+              .file(p.join(example.path, deviceTestPath))
+              .existsSync()) {
+            // If the app isn't in test/ folder, look in test_driver/ instead.
+            deviceTestPath = p.join('test_driver', deviceTestName);
+          }
+
+          final List<String> targetPaths = <String>[];
+          if (fileSystem
+              .file(p.join(example.path, deviceTestPath))
+              .existsSync()) {
+            targetPaths.add(deviceTestPath);
+          } else {
+            final Directory integrationTests =
+                fileSystem.directory(p.join(example.path, 'integration_test'));
+
+            if (await integrationTests.exists()) {
+              await for (FileSystemEntity integration_test
+                  in integrationTests.list()) {
+                if (!integration_test.basename.endsWith('_test.dart')) {
+                  continue;
+                }
+                targetPaths
+                    .add(p.relative(integration_test.path, from: example.path));
+              }
+            }
+
+            if (targetPaths.isEmpty) {
+              print('''
+Unable to infer a target application for $driverTestName to drive.
+Tried searching for the following:
+1. test/$deviceTestName
+2. test_driver/$deviceTestName
+3. test_driver/*_test.dart
+''');
+              failingTests.add(p.relative(test.path, from: example.path));
+              continue;
+            }
+          }
+
+          final List<String> driveArgs = <String>['drive'];
+
+          final String enableExperiment = argResults[kEnableExperiment];
+          if (enableExperiment.isNotEmpty) {
+            driveArgs.add('--enable-experiment=$enableExperiment');
+          }
+
+          if (isLinux && isLinuxPlugin(plugin, fileSystem)) {
+            driveArgs.addAll(<String>[
+              '-d',
+              'linux',
+            ]);
+          }
+          if (isMacos && isMacOsPlugin(plugin, fileSystem)) {
+            driveArgs.addAll(<String>[
+              '-d',
+              'macos',
+            ]);
+          }
+          if (isWindows && isWindowsPlugin(plugin, fileSystem)) {
+            driveArgs.addAll(<String>[
+              '-d',
+              'windows',
+            ]);
+          }
+
+          for (final targetPath in targetPaths) {
+            final int exitCode = await processRunner.runAndStream(
+                flutterCommand,
+                [
+                  ...driveArgs,
+                  '--driver',
+                  p.join('test_driver', driverTestName),
+                  '--target',
+                  targetPath,
+                ],
+                workingDir: example,
+                exitOnError: true);
+            if (exitCode != 0) {
+              failingTests.add(p.join(packageName, deviceTestPath));
+            }
+          }
+        }
+      }
+    }
+    print('\n\n');
+
+    if (failingTests.isNotEmpty) {
+      print('The following driver tests are failing (see above for details):');
+      for (String test in failingTests) {
+        print(' * $test');
+      }
+      throw ToolExit(1);
+    }
+
+    print('All driver tests successful!');
+  }
+
+  Future<bool> pluginSupportedOnCurrentPlatform(
+      FileSystemEntity plugin, FileSystem fileSystem) async {
+    final bool isLinux = argResults[kLinux];
+    final bool isMacos = argResults[kMacos];
+    final bool isWindows = argResults[kWindows];
+    final bool isIOS = argResults[kIos];
+    final bool isAndroid = argResults[kAndroid];
+    if (isLinux) {
+      return isLinuxPlugin(plugin, fileSystem);
+    }
+    if (isMacos) {
+      return isMacOsPlugin(plugin, fileSystem);
+    }
+    if (isWindows) {
+      return isWindowsPlugin(plugin, fileSystem);
+    }
+    if (isIOS) {
+      return isIosPlugin(plugin, fileSystem);
+    }
+    if (isAndroid) {
+      return (isAndroidPlugin(plugin, fileSystem));
+    }
+    // When we are here, no flags are specified. Only return true if the plugin supports mobile for legacy command support.
+    // TODO(cyanglaz): Make mobile platforms flags also required like other platforms (breaking change).
+    // https://github.com/flutter/flutter/issues/58285
+    final bool isMobilePlugin =
+        isIosPlugin(plugin, fileSystem) || isAndroidPlugin(plugin, fileSystem);
+    return isMobilePlugin;
+  }
+}
diff --git a/script/tool/lib/src/firebase_test_lab_command.dart b/script/tool/lib/src/firebase_test_lab_command.dart
new file mode 100644
index 0000000..0b4b2a4
--- /dev/null
+++ b/script/tool/lib/src/firebase_test_lab_command.dart
@@ -0,0 +1,264 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'dart:async';
+import 'dart:io' as io;
+
+import 'package:file/file.dart';
+import 'package:path/path.dart' as p;
+import 'package:uuid/uuid.dart';
+
+import 'common.dart';
+
+class FirebaseTestLabCommand extends PluginCommand {
+  FirebaseTestLabCommand(
+    Directory packagesDir,
+    FileSystem fileSystem, {
+    ProcessRunner processRunner = const ProcessRunner(),
+    Print print = print,
+  })  : _print = print,
+        super(packagesDir, fileSystem, processRunner: processRunner) {
+    argParser.addOption(
+      'project',
+      defaultsTo: 'flutter-infra',
+      help: 'The Firebase project name.',
+    );
+    argParser.addOption('service-key',
+        defaultsTo:
+            p.join(io.Platform.environment['HOME'], 'gcloud-service-key.json'));
+    argParser.addOption('test-run-id',
+        defaultsTo: Uuid().v4(),
+        help:
+            'Optional string to append to the results path, to avoid conflicts. '
+            'Randomly chosen on each invocation if none is provided. '
+            'The default shown here is just an example.');
+    argParser.addMultiOption('device',
+        splitCommas: false,
+        defaultsTo: <String>[
+          'model=walleye,version=26',
+          'model=flame,version=29'
+        ],
+        help:
+            'Device model(s) to test. See https://cloud.google.com/sdk/gcloud/reference/firebase/test/android/run for more info');
+    argParser.addOption('results-bucket',
+        defaultsTo: 'gs://flutter_firebase_testlab');
+    argParser.addOption(
+      kEnableExperiment,
+      defaultsTo: '',
+      help: 'Enables the given Dart SDK experiments.',
+    );
+  }
+
+  @override
+  final String name = 'firebase-test-lab';
+
+  @override
+  final String description = 'Runs the instrumentation tests of the example '
+      'apps on Firebase Test Lab.\n\n'
+      'Runs tests in test_instrumentation folder using the '
+      'instrumentation_test package.';
+
+  static const String _gradleWrapper = 'gradlew';
+
+  final Print _print;
+
+  Completer<void> _firebaseProjectConfigured;
+
+  Future<void> _configureFirebaseProject() async {
+    if (_firebaseProjectConfigured != null) {
+      return _firebaseProjectConfigured.future;
+    } else {
+      _firebaseProjectConfigured = Completer<void>();
+    }
+    await processRunner.runAndExitOnError('gcloud', <String>[
+      'auth',
+      'activate-service-account',
+      '--key-file=${argResults['service-key']}',
+    ]);
+    int exitCode = await processRunner.runAndStream('gcloud', <String>[
+      'config',
+      'set',
+      'project',
+      argResults['project'],
+    ]);
+    if (exitCode == 0) {
+      _print('\nFirebase project configured.');
+      return;
+    } else {
+      _print(
+          '\nWarning: gcloud config set returned a non-zero exit code. Continuing anyway.');
+    }
+    _firebaseProjectConfigured.complete(null);
+  }
+
+  @override
+  Future<Null> run() async {
+    checkSharding();
+    final Stream<Directory> packagesWithTests = getPackages().where(
+        (Directory d) =>
+            isFlutterPackage(d, fileSystem) &&
+            fileSystem
+                .directory(p.join(
+                    d.path, 'example', 'android', 'app', 'src', 'androidTest'))
+                .existsSync());
+
+    final List<String> failingPackages = <String>[];
+    final List<String> missingFlutterBuild = <String>[];
+    int resultsCounter =
+        0; // We use a unique GCS bucket for each Firebase Test Lab run
+    await for (Directory package in packagesWithTests) {
+      // See https://github.com/flutter/flutter/issues/38983
+
+      final Directory exampleDirectory =
+          fileSystem.directory(p.join(package.path, 'example'));
+      final String packageName =
+          p.relative(package.path, from: packagesDir.path);
+      _print('\nRUNNING FIREBASE TEST LAB TESTS for $packageName');
+
+      final Directory androidDirectory =
+          fileSystem.directory(p.join(exampleDirectory.path, 'android'));
+
+      final String enableExperiment = argResults[kEnableExperiment];
+      final String encodedEnableExperiment =
+          Uri.encodeComponent('--enable-experiment=$enableExperiment');
+
+      // Ensures that gradle wrapper exists
+      if (!fileSystem
+          .file(p.join(androidDirectory.path, _gradleWrapper))
+          .existsSync()) {
+        final int exitCode = await processRunner.runAndStream(
+            'flutter',
+            <String>[
+              'build',
+              'apk',
+              if (enableExperiment.isNotEmpty)
+                '--enable-experiment=$enableExperiment',
+            ],
+            workingDir: androidDirectory);
+
+        if (exitCode != 0) {
+          failingPackages.add(packageName);
+          continue;
+        }
+        continue;
+      }
+
+      await _configureFirebaseProject();
+
+      int exitCode = await processRunner.runAndStream(
+          p.join(androidDirectory.path, _gradleWrapper),
+          <String>[
+            'app:assembleAndroidTest',
+            '-Pverbose=true',
+            if (enableExperiment.isNotEmpty)
+              '-Pextra-front-end-options=$encodedEnableExperiment',
+            if (enableExperiment.isNotEmpty)
+              '-Pextra-gen-snapshot-options=$encodedEnableExperiment',
+          ],
+          workingDir: androidDirectory);
+
+      if (exitCode != 0) {
+        failingPackages.add(packageName);
+        continue;
+      }
+
+      // Look for tests recursively in folders that start with 'test' and that
+      // live in the root or example folders.
+      bool isTestDir(FileSystemEntity dir) {
+        return p.basename(dir.path).startsWith('test') ||
+            p.basename(dir.path) == 'integration_test';
+      }
+
+      final List<FileSystemEntity> testDirs =
+          package.listSync().where(isTestDir).toList();
+      final Directory example =
+          fileSystem.directory(p.join(package.path, 'example'));
+      testDirs.addAll(example.listSync().where(isTestDir).toList());
+      for (Directory testDir in testDirs) {
+        bool isE2ETest(FileSystemEntity file) {
+          return file.path.endsWith('_e2e.dart') ||
+              (file.parent.basename == 'integration_test' &&
+                  file.path.endsWith('_test.dart'));
+        }
+
+        final List<FileSystemEntity> testFiles = testDir
+            .listSync(recursive: true, followLinks: true)
+            .where(isE2ETest)
+            .toList();
+        for (FileSystemEntity test in testFiles) {
+          exitCode = await processRunner.runAndStream(
+              p.join(androidDirectory.path, _gradleWrapper),
+              <String>[
+                'app:assembleDebug',
+                '-Pverbose=true',
+                '-Ptarget=${test.path}',
+                if (enableExperiment.isNotEmpty)
+                  '-Pextra-front-end-options=$encodedEnableExperiment',
+                if (enableExperiment.isNotEmpty)
+                  '-Pextra-gen-snapshot-options=$encodedEnableExperiment',
+              ],
+              workingDir: androidDirectory);
+
+          if (exitCode != 0) {
+            failingPackages.add(packageName);
+            continue;
+          }
+          final String buildId = io.Platform.environment['CIRRUS_BUILD_ID'];
+          final String testRunId = argResults['test-run-id'];
+          final String resultsDir =
+              'plugins_android_test/$packageName/$buildId/$testRunId/${resultsCounter++}/';
+          final List<String> args = <String>[
+            'firebase',
+            'test',
+            'android',
+            'run',
+            '--type',
+            'instrumentation',
+            '--app',
+            'build/app/outputs/apk/debug/app-debug.apk',
+            '--test',
+            'build/app/outputs/apk/androidTest/debug/app-debug-androidTest.apk',
+            '--timeout',
+            '5m',
+            '--results-bucket=${argResults['results-bucket']}',
+            '--results-dir=${resultsDir}',
+          ];
+          for (String device in argResults['device']) {
+            args.addAll(<String>['--device', device]);
+          }
+          exitCode = await processRunner.runAndStream('gcloud', args,
+              workingDir: exampleDirectory);
+
+          if (exitCode != 0) {
+            failingPackages.add(packageName);
+            continue;
+          }
+        }
+      }
+    }
+
+    _print('\n\n');
+    if (failingPackages.isNotEmpty) {
+      _print(
+          'The instrumentation tests for the following packages are failing (see above for'
+          'details):');
+      for (String package in failingPackages) {
+        _print(' * $package');
+      }
+    }
+    if (missingFlutterBuild.isNotEmpty) {
+      _print('Run "pub global run flutter_plugin_tools build-examples --apk" on'
+          'the following packages before executing tests again:');
+      for (String package in missingFlutterBuild) {
+        _print(' * $package');
+      }
+    }
+
+    if (failingPackages.isNotEmpty || missingFlutterBuild.isNotEmpty) {
+      throw ToolExit(1);
+    }
+
+    _print('All Firebase Test Lab tests successful!');
+  }
+}
diff --git a/script/tool/lib/src/format_command.dart b/script/tool/lib/src/format_command.dart
new file mode 100644
index 0000000..ec326b9
--- /dev/null
+++ b/script/tool/lib/src/format_command.dart
@@ -0,0 +1,147 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'dart:async';
+import 'dart:convert';
+import 'dart:io' as io;
+
+import 'package:file/file.dart';
+import 'package:http/http.dart' as http;
+import 'package:path/path.dart' as p;
+import 'package:quiver/iterables.dart';
+
+import 'common.dart';
+
+const String _googleFormatterUrl =
+    'https://github.com/google/google-java-format/releases/download/google-java-format-1.3/google-java-format-1.3-all-deps.jar';
+
+class FormatCommand extends PluginCommand {
+  FormatCommand(
+    Directory packagesDir,
+    FileSystem fileSystem, {
+    ProcessRunner processRunner = const ProcessRunner(),
+  }) : super(packagesDir, fileSystem, processRunner: processRunner) {
+    argParser.addFlag('travis', hide: true);
+    argParser.addOption('clang-format',
+        defaultsTo: 'clang-format',
+        help: 'Path to executable of clang-format v5.');
+  }
+
+  @override
+  final String name = 'format';
+
+  @override
+  final String description =
+      'Formats the code of all packages (Java, Objective-C, C++, and Dart).\n\n'
+      'This command requires "git", "flutter" and "clang-format" v5 to be in '
+      'your path.';
+
+  @override
+  Future<Null> run() async {
+    checkSharding();
+    final String googleFormatterPath = await _getGoogleFormatterPath();
+
+    await _formatDart();
+    await _formatJava(googleFormatterPath);
+    await _formatCppAndObjectiveC();
+
+    if (argResults['travis']) {
+      final bool modified = await _didModifyAnything();
+      if (modified) {
+        throw ToolExit(1);
+      }
+    }
+  }
+
+  Future<bool> _didModifyAnything() async {
+    final io.ProcessResult modifiedFiles = await processRunner
+        .runAndExitOnError('git', <String>['ls-files', '--modified'],
+            workingDir: packagesDir);
+
+    print('\n\n');
+
+    if (modifiedFiles.stdout.isEmpty) {
+      print('All files formatted correctly.');
+      return false;
+    }
+
+    print('These files are not formatted correctly (see diff below):');
+    LineSplitter.split(modifiedFiles.stdout)
+        .map((String line) => '  $line')
+        .forEach(print);
+
+    print('\nTo fix run "pub global activate flutter_plugin_tools && '
+        'pub global run flutter_plugin_tools format" or copy-paste '
+        'this command into your terminal:');
+
+    print('patch -p1 <<DONE');
+    final io.ProcessResult diff = await processRunner
+        .runAndExitOnError('git', <String>['diff'], workingDir: packagesDir);
+    print(diff.stdout);
+    print('DONE');
+    return true;
+  }
+
+  Future<Null> _formatCppAndObjectiveC() async {
+    print('Formatting all .cc, .cpp, .mm, .m, and .h files...');
+    final Iterable<String> allFiles = <String>[]
+      ..addAll(await _getFilesWithExtension('.h'))
+      ..addAll(await _getFilesWithExtension('.m'))
+      ..addAll(await _getFilesWithExtension('.mm'))
+      ..addAll(await _getFilesWithExtension('.cc'))
+      ..addAll(await _getFilesWithExtension('.cpp'));
+    // Split this into multiple invocations to avoid a
+    // 'ProcessException: Argument list too long'.
+    final Iterable<List<String>> batches = partition(allFiles, 100);
+    for (List<String> batch in batches) {
+      await processRunner.runAndStream(argResults['clang-format'],
+          <String>['-i', '--style=Google']..addAll(batch),
+          workingDir: packagesDir, exitOnError: true);
+    }
+  }
+
+  Future<Null> _formatJava(String googleFormatterPath) async {
+    print('Formatting all .java files...');
+    final Iterable<String> javaFiles = await _getFilesWithExtension('.java');
+    await processRunner.runAndStream('java',
+        <String>['-jar', googleFormatterPath, '--replace']..addAll(javaFiles),
+        workingDir: packagesDir, exitOnError: true);
+  }
+
+  Future<Null> _formatDart() async {
+    // This actually should be fine for non-Flutter Dart projects, no need to
+    // specifically shell out to dartfmt -w in that case.
+    print('Formatting all .dart files...');
+    final Iterable<String> dartFiles = await _getFilesWithExtension('.dart');
+    if (dartFiles.isEmpty) {
+      print(
+          'No .dart files to format. If you set the `--exclude` flag, most likey they were skipped');
+    } else {
+      await processRunner.runAndStream(
+          'flutter', <String>['format']..addAll(dartFiles),
+          workingDir: packagesDir, exitOnError: true);
+    }
+  }
+
+  Future<List<String>> _getFilesWithExtension(String extension) async =>
+      getFiles()
+          .where((File file) => p.extension(file.path) == extension)
+          .map((File file) => file.path)
+          .toList();
+
+  Future<String> _getGoogleFormatterPath() async {
+    final String javaFormatterPath = p.join(
+        p.dirname(p.fromUri(io.Platform.script)),
+        'google-java-format-1.3-all-deps.jar');
+    final File javaFormatterFile = fileSystem.file(javaFormatterPath);
+
+    if (!javaFormatterFile.existsSync()) {
+      print('Downloading Google Java Format...');
+      final http.Response response = await http.get(_googleFormatterUrl);
+      javaFormatterFile.writeAsBytesSync(response.bodyBytes);
+    }
+
+    return javaFormatterPath;
+  }
+}
diff --git a/script/tool/lib/src/java_test_command.dart b/script/tool/lib/src/java_test_command.dart
new file mode 100644
index 0000000..cf605bf
--- /dev/null
+++ b/script/tool/lib/src/java_test_command.dart
@@ -0,0 +1,89 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'dart:async';
+
+import 'package:file/file.dart';
+import 'package:path/path.dart' as p;
+
+import 'common.dart';
+
+class JavaTestCommand extends PluginCommand {
+  JavaTestCommand(
+    Directory packagesDir,
+    FileSystem fileSystem, {
+    ProcessRunner processRunner = const ProcessRunner(),
+  }) : super(packagesDir, fileSystem, processRunner: processRunner);
+
+  @override
+  final String name = 'java-test';
+
+  @override
+  final String description = 'Runs the Java tests of the example apps.\n\n'
+      'Building the apks of the example apps is required before executing this'
+      'command.';
+
+  static const String _gradleWrapper = 'gradlew';
+
+  @override
+  Future<Null> run() async {
+    checkSharding();
+    final Stream<Directory> examplesWithTests = getExamples().where(
+        (Directory d) =>
+            isFlutterPackage(d, fileSystem) &&
+            fileSystem
+                .directory(p.join(d.path, 'android', 'app', 'src', 'test'))
+                .existsSync());
+
+    final List<String> failingPackages = <String>[];
+    final List<String> missingFlutterBuild = <String>[];
+    await for (Directory example in examplesWithTests) {
+      final String packageName =
+          p.relative(example.path, from: packagesDir.path);
+      print('\nRUNNING JAVA TESTS for $packageName');
+
+      final Directory androidDirectory =
+          fileSystem.directory(p.join(example.path, 'android'));
+      if (!fileSystem
+          .file(p.join(androidDirectory.path, _gradleWrapper))
+          .existsSync()) {
+        print('ERROR: Run "flutter build apk" on example app of $packageName'
+            'before executing tests.');
+        missingFlutterBuild.add(packageName);
+        continue;
+      }
+
+      final int exitCode = await processRunner.runAndStream(
+          p.join(androidDirectory.path, _gradleWrapper),
+          <String>['testDebugUnitTest', '--info'],
+          workingDir: androidDirectory);
+      if (exitCode != 0) {
+        failingPackages.add(packageName);
+      }
+    }
+
+    print('\n\n');
+    if (failingPackages.isNotEmpty) {
+      print(
+          'The Java tests for the following packages are failing (see above for'
+          'details):');
+      for (String package in failingPackages) {
+        print(' * $package');
+      }
+    }
+    if (missingFlutterBuild.isNotEmpty) {
+      print('Run "pub global run flutter_plugin_tools build-examples --apk" on'
+          'the following packages before executing tests again:');
+      for (String package in missingFlutterBuild) {
+        print(' * $package');
+      }
+    }
+
+    if (failingPackages.isNotEmpty || missingFlutterBuild.isNotEmpty) {
+      throw ToolExit(1);
+    }
+
+    print('All Java tests successful!');
+  }
+}
diff --git a/script/tool/lib/src/lint_podspecs_command.dart b/script/tool/lib/src/lint_podspecs_command.dart
new file mode 100644
index 0000000..68fd4b6
--- /dev/null
+++ b/script/tool/lib/src/lint_podspecs_command.dart
@@ -0,0 +1,146 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'dart:async';
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:file/file.dart';
+import 'package:path/path.dart' as p;
+import 'package:platform/platform.dart';
+
+import 'common.dart';
+
+typedef void Print(Object object);
+
+/// Lint the CocoaPod podspecs, run the static analyzer on iOS/macOS plugin
+/// platform code, and run unit tests.
+///
+/// See https://guides.cocoapods.org/terminal/commands.html#pod_lib_lint.
+class LintPodspecsCommand extends PluginCommand {
+  LintPodspecsCommand(
+    Directory packagesDir,
+    FileSystem fileSystem, {
+    ProcessRunner processRunner = const ProcessRunner(),
+    this.platform = const LocalPlatform(),
+    Print print = print,
+  })  : _print = print,
+        super(packagesDir, fileSystem, processRunner: processRunner) {
+    argParser.addMultiOption('skip',
+        help:
+            'Skip all linting for podspecs with this basename (example: federated plugins with placeholder podspecs)',
+        valueHelp: 'podspec_file_name');
+    argParser.addMultiOption('ignore-warnings',
+        help:
+            'Do not pass --allow-warnings flag to "pod lib lint" for podspecs with this basename (example: plugins with known warnings)',
+        valueHelp: 'podspec_file_name');
+    argParser.addMultiOption('no-analyze',
+        help:
+            'Do not pass --analyze flag to "pod lib lint" for podspecs with this basename (example: plugins with known analyzer warnings)',
+        valueHelp: 'podspec_file_name');
+  }
+
+  @override
+  final String name = 'podspecs';
+
+  @override
+  List<String> get aliases => <String>['podspec'];
+
+  @override
+  final String description =
+      'Runs "pod lib lint" on all iOS and macOS plugin podspecs.\n\n'
+      'This command requires "pod" and "flutter" to be in your path. Runs on macOS only.';
+
+  final Platform platform;
+
+  final Print _print;
+
+  @override
+  Future<Null> run() async {
+    if (!platform.isMacOS) {
+      _print('Detected platform is not macOS, skipping podspec lint');
+      return;
+    }
+
+    checkSharding();
+
+    await processRunner.runAndExitOnError('which', <String>['pod'],
+        workingDir: packagesDir);
+
+    _print('Starting podspec lint test');
+
+    final List<String> failingPlugins = <String>[];
+    for (File podspec in await _podspecsToLint()) {
+      if (!await _lintPodspec(podspec)) {
+        failingPlugins.add(p.basenameWithoutExtension(podspec.path));
+      }
+    }
+
+    _print('\n\n');
+    if (failingPlugins.isNotEmpty) {
+      _print('The following plugins have podspec errors (see above):');
+      failingPlugins.forEach((String plugin) {
+        _print(' * $plugin');
+      });
+      throw ToolExit(1);
+    }
+  }
+
+  Future<List<File>> _podspecsToLint() async {
+    final List<File> podspecs = await getFiles().where((File entity) {
+      final String filePath = entity.path;
+      return p.extension(filePath) == '.podspec' &&
+          !argResults['skip'].contains(p.basenameWithoutExtension(filePath));
+    }).toList();
+
+    podspecs.sort(
+        (File a, File b) => p.basename(a.path).compareTo(p.basename(b.path)));
+    return podspecs;
+  }
+
+  Future<bool> _lintPodspec(File podspec) async {
+    // Do not run the static analyzer on plugins with known analyzer issues.
+    final String podspecPath = podspec.path;
+    final bool runAnalyzer = !argResults['no-analyze']
+        .contains(p.basenameWithoutExtension(podspecPath));
+
+    final String podspecBasename = p.basename(podspecPath);
+    if (runAnalyzer) {
+      _print('Linting and analyzing $podspecBasename');
+    } else {
+      _print('Linting $podspecBasename');
+    }
+
+    // Lint plugin as framework (use_frameworks!).
+    final ProcessResult frameworkResult = await _runPodLint(podspecPath,
+        runAnalyzer: runAnalyzer, libraryLint: true);
+    _print(frameworkResult.stdout);
+    _print(frameworkResult.stderr);
+
+    // Lint plugin as library.
+    final ProcessResult libraryResult = await _runPodLint(podspecPath,
+        runAnalyzer: runAnalyzer, libraryLint: false);
+    _print(libraryResult.stdout);
+    _print(libraryResult.stderr);
+
+    return frameworkResult.exitCode == 0 && libraryResult.exitCode == 0;
+  }
+
+  Future<ProcessResult> _runPodLint(String podspecPath,
+      {bool runAnalyzer, bool libraryLint}) async {
+    final bool allowWarnings = argResults['ignore-warnings']
+        .contains(p.basenameWithoutExtension(podspecPath));
+    final List<String> arguments = <String>[
+      'lib',
+      'lint',
+      podspecPath,
+      if (allowWarnings) '--allow-warnings',
+      if (runAnalyzer) '--analyze',
+      if (libraryLint) '--use-libraries'
+    ];
+
+    return processRunner.run('pod', arguments,
+        workingDir: packagesDir, stdoutEncoding: utf8, stderrEncoding: utf8);
+  }
+}
diff --git a/script/tool/lib/src/list_command.dart b/script/tool/lib/src/list_command.dart
new file mode 100644
index 0000000..7f94daa
--- /dev/null
+++ b/script/tool/lib/src/list_command.dart
@@ -0,0 +1,60 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'dart:async';
+
+import 'package:file/file.dart';
+
+import 'common.dart';
+
+class ListCommand extends PluginCommand {
+  ListCommand(Directory packagesDir, FileSystem fileSystem)
+      : super(packagesDir, fileSystem) {
+    argParser.addOption(
+      _type,
+      defaultsTo: _plugin,
+      allowed: <String>[_plugin, _example, _package, _file],
+      help: 'What type of file system content to list.',
+    );
+  }
+
+  static const String _type = 'type';
+  static const String _plugin = 'plugin';
+  static const String _example = 'example';
+  static const String _package = 'package';
+  static const String _file = 'file';
+
+  @override
+  final String name = 'list';
+
+  @override
+  final String description = 'Lists packages or files';
+
+  @override
+  Future<Null> run() async {
+    checkSharding();
+    switch (argResults[_type]) {
+      case _plugin:
+        await for (Directory package in getPlugins()) {
+          print(package.path);
+        }
+        break;
+      case _example:
+        await for (Directory package in getExamples()) {
+          print(package.path);
+        }
+        break;
+      case _package:
+        await for (Directory package in getPackages()) {
+          print(package.path);
+        }
+        break;
+      case _file:
+        await for (File file in getFiles()) {
+          print(file.path);
+        }
+        break;
+    }
+  }
+}
diff --git a/script/tool/lib/src/main.dart b/script/tool/lib/src/main.dart
new file mode 100644
index 0000000..bb3f67c
--- /dev/null
+++ b/script/tool/lib/src/main.dart
@@ -0,0 +1,63 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'dart:io' as io;
+
+import 'package:args/command_runner.dart';
+import 'package:file/file.dart';
+import 'package:file/local.dart';
+import 'package:flutter_plugin_tools/src/publish_plugin_command.dart';
+import 'package:path/path.dart' as p;
+
+import 'analyze_command.dart';
+import 'build_examples_command.dart';
+import 'common.dart';
+import 'create_all_plugins_app_command.dart';
+import 'drive_examples_command.dart';
+import 'firebase_test_lab_command.dart';
+import 'format_command.dart';
+import 'java_test_command.dart';
+import 'lint_podspecs_command.dart';
+import 'list_command.dart';
+import 'test_command.dart';
+import 'version_check_command.dart';
+import 'xctest_command.dart';
+
+void main(List<String> args) {
+  final FileSystem fileSystem = const LocalFileSystem();
+
+  Directory packagesDir = fileSystem
+      .directory(p.join(fileSystem.currentDirectory.path, 'packages'));
+
+  if (!packagesDir.existsSync()) {
+    if (p.basename(fileSystem.currentDirectory.path) == 'packages') {
+      packagesDir = fileSystem.currentDirectory;
+    } else {
+      print('Error: Cannot find a "packages" sub-directory');
+      io.exit(1);
+    }
+  }
+
+  final CommandRunner<Null> commandRunner = CommandRunner<Null>(
+      'pub global run flutter_plugin_tools',
+      'Productivity utils for hosting multiple plugins within one repository.')
+    ..addCommand(AnalyzeCommand(packagesDir, fileSystem))
+    ..addCommand(BuildExamplesCommand(packagesDir, fileSystem))
+    ..addCommand(CreateAllPluginsAppCommand(packagesDir, fileSystem))
+    ..addCommand(DriveExamplesCommand(packagesDir, fileSystem))
+    ..addCommand(FirebaseTestLabCommand(packagesDir, fileSystem))
+    ..addCommand(FormatCommand(packagesDir, fileSystem))
+    ..addCommand(JavaTestCommand(packagesDir, fileSystem))
+    ..addCommand(LintPodspecsCommand(packagesDir, fileSystem))
+    ..addCommand(ListCommand(packagesDir, fileSystem))
+    ..addCommand(PublishPluginCommand(packagesDir, fileSystem))
+    ..addCommand(TestCommand(packagesDir, fileSystem))
+    ..addCommand(VersionCheckCommand(packagesDir, fileSystem))
+    ..addCommand(XCTestCommand(packagesDir, fileSystem));
+
+  commandRunner.run(args).catchError((Object e) {
+    final ToolExit toolExit = e;
+    io.exit(toolExit.exitCode);
+  }, test: (Object e) => e is ToolExit);
+}
diff --git a/script/tool/lib/src/publish_plugin_command.dart b/script/tool/lib/src/publish_plugin_command.dart
new file mode 100644
index 0000000..f7e3b5d
--- /dev/null
+++ b/script/tool/lib/src/publish_plugin_command.dart
@@ -0,0 +1,223 @@
+import 'dart:async';
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:file/file.dart';
+import 'package:git/git.dart';
+import 'package:meta/meta.dart';
+import 'package:path/path.dart' as p;
+import 'package:yaml/yaml.dart';
+
+import 'common.dart';
+
+/// Wraps pub publish with a few niceties used by the flutter/plugin team.
+///
+/// 1. Checks for any modified files in git and refuses to publish if there's an
+///    issue.
+/// 2. Tags the release with the format <package-name>-v<package-version>.
+/// 3. Pushes the release to a remote.
+///
+/// Both 2 and 3 are optional, see `plugin_tools help publish-plugin` for full
+/// usage information.
+///
+/// [processRunner], [print], and [stdin] can be overriden for easier testing.
+class PublishPluginCommand extends PluginCommand {
+  PublishPluginCommand(
+    Directory packagesDir,
+    FileSystem fileSystem, {
+    ProcessRunner processRunner = const ProcessRunner(),
+    Print print = print,
+    Stdin stdinput,
+  })  : _print = print,
+        _stdin = stdinput ?? stdin,
+        super(packagesDir, fileSystem, processRunner: processRunner) {
+    argParser.addOption(
+      _packageOption,
+      help: 'The package to publish.'
+          'If the package directory name is different than its pubspec.yaml name, then this should specify the directory.',
+    );
+    argParser.addMultiOption(_pubFlagsOption,
+        help:
+            'A list of options that will be forwarded on to pub. Separate multiple flags with commas.');
+    argParser.addFlag(
+      _tagReleaseOption,
+      help: 'Whether or not to tag the release.',
+      defaultsTo: true,
+      negatable: true,
+    );
+    argParser.addFlag(
+      _pushTagsOption,
+      help:
+          'Whether or not tags should be pushed to a remote after creation. Ignored if tag-release is false.',
+      defaultsTo: true,
+      negatable: true,
+    );
+    argParser.addOption(
+      _remoteOption,
+      help:
+          'The name of the remote to push the tags to. Ignored if push-tags or tag-release is false.',
+      // Flutter convention is to use "upstream" for the single source of truth, and "origin" for personal forks.
+      defaultsTo: 'upstream',
+    );
+  }
+
+  static const String _packageOption = 'package';
+  static const String _tagReleaseOption = 'tag-release';
+  static const String _pushTagsOption = 'push-tags';
+  static const String _pubFlagsOption = 'pub-publish-flags';
+  static const String _remoteOption = 'remote';
+
+  // Version tags should follow <package-name>-v<semantic-version>. For example,
+  // `flutter_plugin_tools-v0.0.24`.
+  static const String _tagFormat = '%PACKAGE%-v%VERSION%';
+
+  @override
+  final String name = 'publish-plugin';
+
+  @override
+  final String description =
+      'Attempts to publish the given plugin and tag its release on GitHub.';
+
+  final Print _print;
+  final Stdin _stdin;
+  // The directory of the actual package that we are publishing.
+  Directory _packageDir;
+  StreamSubscription<String> _stdinSubscription;
+
+  @override
+  Future<Null> run() async {
+    checkSharding();
+    _print('Checking local repo...');
+    _packageDir = _checkPackageDir();
+    await _checkGitStatus();
+    final bool shouldPushTag = argResults[_pushTagsOption];
+    final String remote = argResults[_remoteOption];
+    String remoteUrl;
+    if (shouldPushTag) {
+      remoteUrl = await _verifyRemote(remote);
+    }
+    _print('Local repo is ready!');
+
+    await _publish();
+    _print('Package published!');
+    if (!argResults[_tagReleaseOption]) {
+      return await _finishSuccesfully();
+    }
+
+    _print('Tagging release...');
+    final String tag = _getTag();
+    await processRunner.runAndExitOnError('git', <String>['tag', tag],
+        workingDir: _packageDir);
+    if (!shouldPushTag) {
+      return await _finishSuccesfully();
+    }
+
+    _print('Pushing tag to $remote...');
+    await _pushTagToRemote(remote: remote, tag: tag, remoteUrl: remoteUrl);
+    await _finishSuccesfully();
+  }
+
+  Future<void> _finishSuccesfully() async {
+    await _stdinSubscription.cancel();
+    _print('Done!');
+  }
+
+  Directory _checkPackageDir() {
+    final String package = argResults[_packageOption];
+    if (package == null) {
+      _print(
+          'Must specify a package to publish. See `plugin_tools help publish-plugin`.');
+      throw ToolExit(1);
+    }
+    final Directory _packageDir = packagesDir.childDirectory(package);
+    if (!_packageDir.existsSync()) {
+      _print('${_packageDir.absolute.path} does not exist.');
+      throw ToolExit(1);
+    }
+    return _packageDir;
+  }
+
+  Future<void> _checkGitStatus() async {
+    if (!await GitDir.isGitDir(packagesDir.path)) {
+      _print('$packagesDir is not a valid Git repository.');
+      throw ToolExit(1);
+    }
+
+    final ProcessResult statusResult = await processRunner.runAndExitOnError(
+        'git',
+        <String>[
+          'status',
+          '--porcelain',
+          '--ignored',
+          _packageDir.absolute.path
+        ],
+        workingDir: _packageDir);
+    final String statusOutput = statusResult.stdout;
+    if (statusOutput.isNotEmpty) {
+      _print(
+          "There are files in the package directory that haven't been saved in git. Refusing to publish these files:\n\n"
+          '$statusOutput\n'
+          'If the directory should be clean, you can run `git clean -xdf && git reset --hard HEAD` to wipe all local changes.');
+      throw ToolExit(1);
+    }
+  }
+
+  Future<String> _verifyRemote(String remote) async {
+    final ProcessResult remoteInfo = await processRunner.runAndExitOnError(
+        'git', <String>['remote', 'get-url', remote],
+        workingDir: _packageDir);
+    return remoteInfo.stdout;
+  }
+
+  Future<void> _publish() async {
+    final List<String> publishFlags = argResults[_pubFlagsOption];
+    _print(
+        'Running `pub publish ${publishFlags.join(' ')}` in ${_packageDir.absolute.path}...\n');
+    final Process publish = await processRunner.start(
+        'flutter', <String>['pub', 'publish'] + publishFlags,
+        workingDirectory: _packageDir);
+    publish.stdout
+        .transform(utf8.decoder)
+        .listen((String data) => _print(data));
+    publish.stderr
+        .transform(utf8.decoder)
+        .listen((String data) => _print(data));
+    _stdinSubscription = _stdin
+        .transform(utf8.decoder)
+        .listen((String data) => publish.stdin.writeln(data));
+    final int result = await publish.exitCode;
+    if (result != 0) {
+      _print('Publish failed. Exiting.');
+      throw ToolExit(result);
+    }
+  }
+
+  String _getTag() {
+    final File pubspecFile =
+        fileSystem.file(p.join(_packageDir.path, 'pubspec.yaml'));
+    final YamlMap pubspecYaml = loadYaml(pubspecFile.readAsStringSync());
+    final String name = pubspecYaml['name'];
+    final String version = pubspecYaml['version'];
+    // We should have failed to publish if these were unset.
+    assert(name.isNotEmpty && version.isNotEmpty);
+    return _tagFormat
+        .replaceAll('%PACKAGE%', name)
+        .replaceAll('%VERSION%', version);
+  }
+
+  Future<void> _pushTagToRemote(
+      {@required String remote,
+      @required String tag,
+      @required String remoteUrl}) async {
+    assert(remote != null && tag != null && remoteUrl != null);
+    _print('Ready to push $tag to $remoteUrl (y/n)?');
+    final String input = _stdin.readLineSync();
+    if (input.toLowerCase() != 'y') {
+      _print('Tag push canceled.');
+      throw ToolExit(1);
+    }
+
+    await processRunner.runAndExitOnError('git', <String>['push', remote, tag],
+        workingDir: packagesDir);
+  }
+}
diff --git a/script/tool/lib/src/test_command.dart b/script/tool/lib/src/test_command.dart
new file mode 100644
index 0000000..e938168
--- /dev/null
+++ b/script/tool/lib/src/test_command.dart
@@ -0,0 +1,101 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'dart:async';
+
+import 'package:file/file.dart';
+import 'package:path/path.dart' as p;
+
+import 'common.dart';
+
+class TestCommand extends PluginCommand {
+  TestCommand(
+    Directory packagesDir,
+    FileSystem fileSystem, {
+    ProcessRunner processRunner = const ProcessRunner(),
+  }) : super(packagesDir, fileSystem, processRunner: processRunner) {
+    argParser.addOption(
+      kEnableExperiment,
+      defaultsTo: '',
+      help: 'Runs the tests in Dart VM with the given experiments enabled.',
+    );
+  }
+
+  @override
+  final String name = 'test';
+
+  @override
+  final String description = 'Runs the Dart tests for all packages.\n\n'
+      'This command requires "flutter" to be in your path.';
+
+  @override
+  Future<Null> run() async {
+    checkSharding();
+    final List<String> failingPackages = <String>[];
+    await for (Directory packageDir in getPackages()) {
+      final String packageName =
+          p.relative(packageDir.path, from: packagesDir.path);
+      if (!fileSystem.directory(p.join(packageDir.path, 'test')).existsSync()) {
+        print('SKIPPING $packageName - no test subdirectory');
+        continue;
+      }
+
+      print('RUNNING $packageName tests...');
+
+      final String enableExperiment = argResults[kEnableExperiment];
+
+      // `flutter test` automatically gets packages.  `pub run test` does not.  :(
+      int exitCode = 0;
+      if (isFlutterPackage(packageDir, fileSystem)) {
+        final List<String> args = <String>[
+          'test',
+          '--color',
+          if (enableExperiment.isNotEmpty)
+            '--enable-experiment=$enableExperiment',
+        ];
+
+        if (isWebPlugin(packageDir, fileSystem)) {
+          args.add('--platform=chrome');
+        }
+        exitCode = await processRunner.runAndStream(
+          'flutter',
+          args,
+          workingDir: packageDir,
+        );
+      } else {
+        exitCode = await processRunner.runAndStream(
+          'pub',
+          <String>['get'],
+          workingDir: packageDir,
+        );
+        if (exitCode == 0) {
+          exitCode = await processRunner.runAndStream(
+            'pub',
+            <String>[
+              'run',
+              if (enableExperiment.isNotEmpty)
+                '--enable-experiment=$enableExperiment',
+              'test',
+            ],
+            workingDir: packageDir,
+          );
+        }
+      }
+      if (exitCode != 0) {
+        failingPackages.add(packageName);
+      }
+    }
+
+    print('\n\n');
+    if (failingPackages.isNotEmpty) {
+      print('Tests for the following packages are failing (see above):');
+      failingPackages.forEach((String package) {
+        print(' * $package');
+      });
+      throw ToolExit(1);
+    }
+
+    print('All tests are passing!');
+  }
+}
diff --git a/script/tool/lib/src/version_check_command.dart b/script/tool/lib/src/version_check_command.dart
new file mode 100644
index 0000000..2c6b92b
--- /dev/null
+++ b/script/tool/lib/src/version_check_command.dart
@@ -0,0 +1,220 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'dart:async';
+import 'dart:io' as io;
+
+import 'package:meta/meta.dart';
+import 'package:colorize/colorize.dart';
+import 'package:file/file.dart';
+import 'package:git/git.dart';
+import 'package:pub_semver/pub_semver.dart';
+import 'package:pubspec_parse/pubspec_parse.dart';
+import 'package:yaml/yaml.dart';
+
+import 'common.dart';
+
+const String _kBaseSha = 'base_sha';
+
+class GitVersionFinder {
+  GitVersionFinder(this.baseGitDir, this.baseSha);
+
+  final GitDir baseGitDir;
+  final String baseSha;
+
+  static bool isPubspec(String file) {
+    return file.trim().endsWith('pubspec.yaml');
+  }
+
+  Future<List<String>> getChangedPubSpecs() async {
+    final io.ProcessResult changedFilesCommand = await baseGitDir
+        .runCommand(<String>['diff', '--name-only', '$baseSha', 'HEAD']);
+    final List<String> changedFiles =
+        changedFilesCommand.stdout.toString().split('\n');
+    return changedFiles.where(isPubspec).toList();
+  }
+
+  Future<Version> getPackageVersion(String pubspecPath, String gitRef) async {
+    final io.ProcessResult gitShow =
+        await baseGitDir.runCommand(<String>['show', '$gitRef:$pubspecPath']);
+    final String fileContent = gitShow.stdout;
+    final String versionString = loadYaml(fileContent)['version'];
+    return versionString == null ? null : Version.parse(versionString);
+  }
+}
+
+enum NextVersionType {
+  BREAKING_MAJOR,
+  MAJOR_NULLSAFETY_PRE_RELEASE,
+  MINOR_NULLSAFETY_PRE_RELEASE,
+  MINOR,
+  PATCH,
+  RELEASE,
+}
+
+Version getNextNullSafetyPreRelease(Version current, Version next) {
+  String nextNullsafetyPrerelease = 'nullsafety';
+  if (current.isPreRelease &&
+      current.preRelease.first is String &&
+      current.preRelease.first == 'nullsafety') {
+    if (current.preRelease.length == 1) {
+      nextNullsafetyPrerelease = 'nullsafety.1';
+    } else if (current.preRelease.length == 2 &&
+        current.preRelease.last is int) {
+      nextNullsafetyPrerelease = 'nullsafety.${current.preRelease.last + 1}';
+    }
+  }
+  return Version(
+    next.major,
+    next.minor,
+    next.patch,
+    pre: nextNullsafetyPrerelease,
+  );
+}
+
+@visibleForTesting
+Map<Version, NextVersionType> getAllowedNextVersions(
+    Version masterVersion, Version headVersion) {
+  final Version nextNullSafetyMajor =
+      getNextNullSafetyPreRelease(masterVersion, masterVersion.nextMajor);
+  final Version nextNullSafetyMinor =
+      getNextNullSafetyPreRelease(masterVersion, masterVersion.nextMinor);
+  final Map<Version, NextVersionType> allowedNextVersions =
+      <Version, NextVersionType>{
+    masterVersion.nextMajor: NextVersionType.BREAKING_MAJOR,
+    nextNullSafetyMajor: NextVersionType.MAJOR_NULLSAFETY_PRE_RELEASE,
+    nextNullSafetyMinor: NextVersionType.MINOR_NULLSAFETY_PRE_RELEASE,
+    masterVersion.nextMinor: NextVersionType.MINOR,
+    masterVersion.nextPatch: NextVersionType.PATCH,
+  };
+
+  if (masterVersion.major < 1 && headVersion.major < 1) {
+    int nextBuildNumber = -1;
+    if (masterVersion.build.isEmpty) {
+      nextBuildNumber = 1;
+    } else {
+      final int currentBuildNumber = masterVersion.build.first;
+      nextBuildNumber = currentBuildNumber + 1;
+    }
+    final Version preReleaseVersion = Version(
+      masterVersion.major,
+      masterVersion.minor,
+      masterVersion.patch,
+      build: nextBuildNumber.toString(),
+    );
+    allowedNextVersions.clear();
+    allowedNextVersions[masterVersion.nextMajor] = NextVersionType.RELEASE;
+    allowedNextVersions[masterVersion.nextMinor] =
+        NextVersionType.BREAKING_MAJOR;
+    allowedNextVersions[masterVersion.nextPatch] = NextVersionType.MINOR;
+    allowedNextVersions[preReleaseVersion] = NextVersionType.PATCH;
+
+    final Version nextNullSafetyMajor =
+        getNextNullSafetyPreRelease(masterVersion, masterVersion.nextMinor);
+    final Version nextNullSafetyMinor =
+        getNextNullSafetyPreRelease(masterVersion, masterVersion.nextPatch);
+
+    allowedNextVersions[nextNullSafetyMajor] =
+        NextVersionType.MAJOR_NULLSAFETY_PRE_RELEASE;
+    allowedNextVersions[nextNullSafetyMinor] =
+        NextVersionType.MINOR_NULLSAFETY_PRE_RELEASE;
+  }
+  return allowedNextVersions;
+}
+
+class VersionCheckCommand extends PluginCommand {
+  VersionCheckCommand(
+    Directory packagesDir,
+    FileSystem fileSystem, {
+    ProcessRunner processRunner = const ProcessRunner(),
+    this.gitDir,
+  }) : super(packagesDir, fileSystem, processRunner: processRunner) {
+    argParser.addOption(_kBaseSha);
+  }
+
+  /// The git directory to use. By default it uses the parent directory.
+  ///
+  /// This can be mocked for testing.
+  final GitDir gitDir;
+
+  @override
+  final String name = 'version-check';
+
+  @override
+  final String description =
+      'Checks if the versions of the plugins have been incremented per pub specification.\n\n'
+      'This command requires "pub" and "flutter" to be in your path.';
+
+  @override
+  Future<Null> run() async {
+    checkSharding();
+
+    final String rootDir = packagesDir.parent.absolute.path;
+    final String baseSha = argResults[_kBaseSha];
+
+    GitDir baseGitDir = gitDir;
+    if (baseGitDir == null) {
+      if (!await GitDir.isGitDir(rootDir)) {
+        print('$rootDir is not a valid Git repository.');
+        throw ToolExit(2);
+      }
+      baseGitDir = await GitDir.fromExisting(rootDir);
+    }
+
+    final GitVersionFinder gitVersionFinder =
+        GitVersionFinder(baseGitDir, baseSha);
+
+    final List<String> changedPubspecs =
+        await gitVersionFinder.getChangedPubSpecs();
+
+    for (final String pubspecPath in changedPubspecs) {
+      try {
+        final File pubspecFile = fileSystem.file(pubspecPath);
+        if (!pubspecFile.existsSync()) {
+          continue;
+        }
+        final Pubspec pubspec = Pubspec.parse(pubspecFile.readAsStringSync());
+        if (pubspec.publishTo == 'none') {
+          continue;
+        }
+
+        final Version masterVersion =
+            await gitVersionFinder.getPackageVersion(pubspecPath, baseSha);
+        final Version headVersion =
+            await gitVersionFinder.getPackageVersion(pubspecPath, 'HEAD');
+        if (headVersion == null) {
+          continue; // Example apps don't have versions
+        }
+
+        final Map<Version, NextVersionType> allowedNextVersions =
+            getAllowedNextVersions(masterVersion, headVersion);
+
+        if (!allowedNextVersions.containsKey(headVersion)) {
+          final String error = '$pubspecPath incorrectly updated version.\n'
+              'HEAD: $headVersion, master: $masterVersion.\n'
+              'Allowed versions: $allowedNextVersions';
+          final Colorize redError = Colorize(error)..red();
+          print(redError);
+          throw ToolExit(1);
+        }
+
+        bool isPlatformInterface = pubspec.name.endsWith("_platform_interface");
+        if (isPlatformInterface &&
+            allowedNextVersions[headVersion] ==
+                NextVersionType.BREAKING_MAJOR) {
+          final String error = '$pubspecPath breaking change detected.\n'
+              'Breaking changes to platform interfaces are strongly discouraged.\n';
+          final Colorize redError = Colorize(error)..red();
+          print(redError);
+          throw ToolExit(1);
+        }
+      } on io.ProcessException {
+        print('Unable to find pubspec in master for $pubspecPath.'
+            ' Safe to ignore if the project is new.');
+      }
+    }
+
+    print('No version check errors found!');
+  }
+}
diff --git a/script/tool/lib/src/xctest_command.dart b/script/tool/lib/src/xctest_command.dart
new file mode 100644
index 0000000..d90b7a8
--- /dev/null
+++ b/script/tool/lib/src/xctest_command.dart
@@ -0,0 +1,216 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'dart:async';
+import 'dart:convert';
+import 'dart:io' as io;
+
+import 'package:file/file.dart';
+import 'package:path/path.dart' as p;
+
+import 'common.dart';
+
+const String _kiOSDestination = 'ios-destination';
+const String _kTarget = 'target';
+const String _kSkip = 'skip';
+const String _kXcodeBuildCommand = 'xcodebuild';
+const String _kXCRunCommand = 'xcrun';
+const String _kFoundNoSimulatorsMessage =
+    'Cannot find any available simulators, tests failed';
+
+/// The command to run iOS' XCTests in plugins, this should work for both XCUnitTest and XCUITest targets.
+/// The tests target have to be added to the xcode project of the example app. Usually at "example/ios/Runner.xcodeproj".
+/// The command takes a "-target" argument which has to match the target of the test target.
+/// For information on how to add test target in an xcode project, see https://developer.apple.com/library/archive/documentation/ToolsLanguages/Conceptual/Xcode_Overview/UnitTesting.html
+class XCTestCommand extends PluginCommand {
+  XCTestCommand(
+    Directory packagesDir,
+    FileSystem fileSystem, {
+    ProcessRunner processRunner = const ProcessRunner(),
+  }) : super(packagesDir, fileSystem, processRunner: processRunner) {
+    argParser.addOption(
+      _kiOSDestination,
+      help:
+          'Specify the destination when running the test, used for -destination flag for xcodebuild command.\n'
+          'this is passed to the `-destination` argument in xcodebuild command.\n'
+          'See https://developer.apple.com/library/archive/technotes/tn2339/_index.html#//apple_ref/doc/uid/DTS40014588-CH1-UNIT for details on how to specify the destination.',
+    );
+    argParser.addOption(_kTarget,
+        help: 'The test target.\n'
+            'This is the xcode project test target. This is passed to the `-scheme` argument in the xcodebuild command. \n'
+            'See https://developer.apple.com/library/archive/technotes/tn2339/_index.html#//apple_ref/doc/uid/DTS40014588-CH1-UNIT for details on how to specify the scheme');
+    argParser.addMultiOption(_kSkip,
+        help: 'Plugins to skip while running this command. \n');
+  }
+
+  @override
+  final String name = 'xctest';
+
+  @override
+  final String description = 'Runs the xctests in the iOS example apps.\n\n'
+      'This command requires "flutter" to be in your path.';
+
+  @override
+  Future<Null> run() async {
+    if (argResults[_kTarget] == null) {
+      // TODO(cyanglaz): Automatically find all the available testing schemes if this argument is not specified.
+      // https://github.com/flutter/flutter/issues/68419
+      print('--$_kTarget must be specified');
+      throw ToolExit(1);
+    }
+
+    String destination = argResults[_kiOSDestination];
+    if (destination == null) {
+      String simulatorId = await _findAvailableIphoneSimulator();
+      if (simulatorId == null) {
+        print(_kFoundNoSimulatorsMessage);
+        throw ToolExit(1);
+      }
+      destination = 'id=$simulatorId';
+    }
+
+    checkSharding();
+
+    final String target = argResults[_kTarget];
+    final List<String> skipped = argResults[_kSkip];
+
+    List<String> failingPackages = <String>[];
+    await for (Directory plugin in getPlugins()) {
+      // Start running for package.
+      final String packageName =
+          p.relative(plugin.path, from: packagesDir.path);
+      print('Start running for $packageName ...');
+      if (!isIosPlugin(plugin, fileSystem)) {
+        print('iOS is not supported by this plugin.');
+        print('\n\n');
+        continue;
+      }
+      if (skipped.contains(packageName)) {
+        print('$packageName was skipped with the --skip flag.');
+        print('\n\n');
+        continue;
+      }
+      for (Directory example in getExamplesForPlugin(plugin)) {
+        // Look for the test scheme in the example app.
+        print('Look for target named: $_kTarget ...');
+        final List<String> findSchemeArgs = <String>[
+          '-project',
+          'ios/Runner.xcodeproj',
+          '-list',
+          '-json'
+        ];
+        final String completeFindSchemeCommand =
+            '$_kXcodeBuildCommand ${findSchemeArgs.join(' ')}';
+        print(completeFindSchemeCommand);
+        final io.ProcessResult xcodeprojListResult = await processRunner
+            .run(_kXcodeBuildCommand, findSchemeArgs, workingDir: example);
+        if (xcodeprojListResult.exitCode != 0) {
+          print('Error occurred while running "$completeFindSchemeCommand":\n'
+              '${xcodeprojListResult.stderr}');
+          failingPackages.add(packageName);
+          print('\n\n');
+          continue;
+        }
+
+        final String xcodeprojListOutput = xcodeprojListResult.stdout;
+        Map<String, dynamic> xcodeprojListOutputJson =
+            jsonDecode(xcodeprojListOutput);
+        if (!xcodeprojListOutputJson['project']['targets'].contains(target)) {
+          failingPackages.add(packageName);
+          print('$target not configured for $packageName, test failed.');
+          print(
+              'Please check the scheme for the test target if it matches the name $target.\n'
+              'If this plugin does not have an XCTest target, use the $_kSkip flag in the $name command to skip the plugin.');
+          print('\n\n');
+          continue;
+        }
+        // Found the scheme, running tests
+        print('Running XCTests:$target for $packageName ...');
+        final List<String> xctestArgs = <String>[
+          'test',
+          '-workspace',
+          'ios/Runner.xcworkspace',
+          '-scheme',
+          target,
+          '-destination',
+          destination,
+          'CODE_SIGN_IDENTITY=""',
+          'CODE_SIGNING_REQUIRED=NO'
+        ];
+        final String completeTestCommand =
+            '$_kXcodeBuildCommand ${xctestArgs.join(' ')}';
+        print(completeTestCommand);
+        final int exitCode = await processRunner
+            .runAndStream(_kXcodeBuildCommand, xctestArgs, workingDir: example);
+        if (exitCode == 0) {
+          print('Successfully ran xctest for $packageName');
+        } else {
+          failingPackages.add(packageName);
+        }
+      }
+    }
+
+    // Command end, print reports.
+    if (failingPackages.isEmpty) {
+      print("All XCTests have passed!");
+    } else {
+      print(
+          'The following packages are failing XCTests (see above for details):');
+      for (String package in failingPackages) {
+        print(' * $package');
+      }
+      throw ToolExit(1);
+    }
+  }
+
+  Future<String> _findAvailableIphoneSimulator() async {
+    // Find the first available destination if not specified.
+    final List<String> findSimulatorsArguments = <String>[
+      'simctl',
+      'list',
+      '--json'
+    ];
+    final String findSimulatorCompleteCommand =
+        '$_kXCRunCommand ${findSimulatorsArguments.join(' ')}';
+    print('Looking for available simulators...');
+    print(findSimulatorCompleteCommand);
+    final io.ProcessResult findSimulatorsResult =
+        await processRunner.run(_kXCRunCommand, findSimulatorsArguments);
+    if (findSimulatorsResult.exitCode != 0) {
+      print('Error occurred while running "$findSimulatorCompleteCommand":\n'
+          '${findSimulatorsResult.stderr}');
+      throw ToolExit(1);
+    }
+    final Map<String, dynamic> simulatorListJson =
+        jsonDecode(findSimulatorsResult.stdout);
+    final List<dynamic> runtimes = simulatorListJson['runtimes'];
+    final Map<String, dynamic> devices = simulatorListJson['devices'];
+    if (runtimes.isEmpty || devices.isEmpty) {
+      return null;
+    }
+    String id;
+    // Looking for runtimes, trying to find one with highest OS version.
+    for (Map<String, dynamic> runtimeMap in runtimes.reversed) {
+      if (!runtimeMap['name'].contains('iOS')) {
+        continue;
+      }
+      final String runtimeID = runtimeMap['identifier'];
+      final List<dynamic> devicesForRuntime = devices[runtimeID];
+      if (devicesForRuntime.isEmpty) {
+        continue;
+      }
+      // Looking for runtimes, trying to find latest version of device.
+      for (Map<String, dynamic> device in devicesForRuntime.reversed) {
+        if (device['availabilityError'] != null ||
+            (device['isAvailable'] as bool == false)) {
+          continue;
+        }
+        id = device['udid'];
+        print('device selected: $device');
+        return id;
+      }
+    }
+    return null;
+  }
+}
diff --git a/script/tool/pubspec.yaml b/script/tool/pubspec.yaml
new file mode 100644
index 0000000..d9fce4a
--- /dev/null
+++ b/script/tool/pubspec.yaml
@@ -0,0 +1,25 @@
+name: flutter_plugin_tools
+description: Productivity utils for hosting multiple plugins within one repository.
+publish_to: 'none'
+
+dependencies:
+  args: "^1.4.3"
+  path: "^1.6.1"
+  http: "^0.12.1"
+  async: "^2.0.7"
+  yaml: "^2.1.15"
+  quiver: "^2.0.2"
+  pub_semver: ^1.4.2
+  colorize: ^2.0.0
+  git: ^1.0.0
+  platform: ^2.2.0
+  pubspec_parse: "^0.1.4"
+  test: ^1.6.4
+  meta: ^1.1.7
+  file: ^5.0.10
+  uuid: ^2.0.4
+  http_multi_server: ^2.2.0
+  collection: 1.14.13
+
+environment:
+  sdk: ">=2.3.0 <3.0.0"