pkg/dartdev/lib/src/commands/install.dart - sdk.git - Git at Google

 // Copyright (c) 2025, the Dart project authors.  Please see the AUTHORS file
 // for details. 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';

 import 'package:dartdev/src/commands/build.dart';
 import 'package:dartdev/src/install/file_system.dart';
 import 'package:dartdev/src/install/pub_formats.dart';
 import 'package:path/path.dart' as p;
 import 'package:pub/pub.dart';
 import 'package:pub_formats/pub_formats.dart';

 import '../core.dart';

 class InstallCommand extends DartdevCommand {
   static const cmdName = 'install';
   static const cmdDescription =
       '''Install or upgrade a Dart CLI tool for global use.

 Install all executables specified in a package's pubspec.yaml executables
 section (https://dart.dev/tools/pub/pubspec#executables) on the PATH. If the
 executables section doesn't exist, installs all `bin/*.dart` entry points as
 executables.

 If the same package has been previously installed, it will be overwritten.

 You can specify three different values for the <package> argument:
 1. A package name. This will install the package from pub.dev. (hosted)
    The [version-constraint] argument can only be passed to 'hosted'.
 2. A git url. This will install the package from a git repository. (git)
 3. A path on your machine. This will install the package from that path. (path)''';
   static const int genericErrorExitCode = 255;

   @override
   String get invocation {
     final superNoArguments = super.invocation.replaceAll(' [arguments]', '');
     return '$superNoArguments <package> [version-constraint]';
   }

   @override
   CommandCategory get commandCategory => CommandCategory.global;

   InstallCommand({bool verbose = false})
       : super(cmdName, cmdDescription, verbose) {
     argParser.addOption(
       'git-path',
       help: 'Path of git package in repository. '
           'Only applies when using a git url for <package>.',
     );

     argParser.addOption(
       'git-ref',
       help: 'Git branch or commit to be retrieved. '
           'Only applies when using a git url for <package>.',
     );

     argParser.addFlag(
       'overwrite',
       negatable: false,
       help: 'Overwrite executables from other packages with the same name.',
     );

     argParser.addOption(
       'hosted-url',
       abbr: 'u',
       help: 'A custom pub server URL for the package. '
           'Only applies when using a package name for <package>.',
     );
   }

   /// Parses the arguments.
   ///
   /// Reports usage errors to user if the wrong number or arguments or the wrong
   /// flags are passed.
   _InstallCommandParsedArguments _parseArguments() {
     final argResults = this.argResults!;

     final overwrite = argResults.flag('overwrite');

     Iterable<String> args = argResults.rest;

     String readArg([String error = '']) {
       if (args.isEmpty) usageException(error);
       final arg = args.first;
       args = args.skip(1);
       return arg;
     }

     final argument = readArg('No package source given.');
     final sourceKind = _SourceKind.fromArgument(argument);

     final gitPath = argResults.option('git-path');
     var gitRef = argResults.option('git-ref');
     if (sourceKind != _SourceKind.git && (gitPath != null || gitRef != null)) {
       usageException(
         'Options `--git-path` and `--git-ref` '
         'can only be used with a git source.',
       );
     }

     final hostedUrl = argResults.option('hosted-url');
     if (sourceKind != _SourceKind.hosted && hostedUrl != null) {
       usageException(
         'Option `--hosted-url` can only be used with a hosted source.',
       );
     }

     String? versionConstraint;
     switch (sourceKind) {
       case _SourceKind.git:
       case _SourceKind.path:
         break;
       case _SourceKind.hosted:
         versionConstraint = args.isEmpty ? 'any' : readArg();
     }
     if (args.isNotEmpty) {
       usageException(
         'Too many arguments, did not expect "${args.join(' ')}"',
       );
     }
     return _InstallCommandParsedArguments._(
       source: argument,
       sourceKind: sourceKind,
       versionConstraint: versionConstraint,
       gitPath: gitPath,
       gitRef: gitRef,
       hostedUrl: hostedUrl,
       overwrite: overwrite,
     );
   }

   Future<String> _findPackageName(
     _InstallCommandParsedArguments parsedArgs,
   ) async {
     switch (parsedArgs.sourceKind) {
       case _SourceKind.git:
         return await getPackageNameFromGitRepo(
           parsedArgs.source,
           ref: parsedArgs.gitRef,
           path: parsedArgs.gitPath,
           relativeTo: Directory.current.path,
           tagPattern: null,
         );
       case _SourceKind.hosted:
         return parsedArgs.source;
       case _SourceKind.path:
         final pubspecFile = File.fromUri(
             Directory(parsedArgs.source).absolute.uri.resolve('pubspec.yaml'));
         if (!await pubspecFile.exists()) {
           usageException('No pubspec found in ${pubspecFile.path}.');
         }
         final pubspecYaml = PubspecYamlFile.loadSync(pubspecFile);
         return pubspecYaml.name;
     }
   }

   /// Creates a helper package to pull in the requested package as a dependency.
   ///
   /// The user provides us either with (1) a package name plus optional version
   /// constraint, (2) a git repo, or (3) a local path. In order to avoid
   /// reimplementing pub's knowledge about how to pull in (1) and (2), we create
   /// a package with a dependency on the package that the user wants to install.
   /// Subsequently, we run `pub get` to let pub pull in dependencies, and we use
   /// the `package_graph.json` to find the root of the package that was pulled
   /// in by pub.
   void _createHelperPackagePubspec({
     required _InstallCommandParsedArguments parsedArgs,
     required String packageName,
     required Directory helperPackageDir,
   }) {
     final tempPubspec =
         File.fromUri(helperPackageDir.uri.resolve('pubspec.yaml'));
     final helperPackagePubspec = PubspecYamlFileSyntax(
       name: _helperPackageName,
       environment: EnvironmentSyntax(
         sdk: '^${Platform.version.split(' ').first}',
       ),
       dependencies: {
         packageName: switch (parsedArgs.sourceKind) {
           _SourceKind.git => GitDependencySourceSyntax(
               git: GitSyntax(
                 url: parsedArgs.source,
                 path$: parsedArgs.gitPath,
                 ref: parsedArgs.gitRef,
               ),
             ),
           _SourceKind.hosted => HostedDependencySourceSyntax(
               hosted: parsedArgs.hostedUrl,
               version: parsedArgs.versionConstraint!,
             ),
           _SourceKind.path =>
             // Re-resolve dependencies for path activate, behave like it would work
             // for users of the package if the activate via hosted or git.
             PathDependencySourceSyntax(
               path$: Directory(parsedArgs.source).absolute.path,
             ),
         }
       },
     );
     helperPackagePubspec.writeSync(tempPubspec);
   }

   static const _helperPackageName = 'dart_install_helper_package';

   Future<void> _resolveHelperPackage(Directory helperPackageDir) async {
     try {
       await ensurePubspecResolved(helperPackageDir.path);
     } on ResolutionFailedException catch (e) {
       _installException(e.message);
     }
   }

   /// The executables that should be placed on the user's PATH when this
   /// package is installed.
   DartBuildExecutables _loadDeclaredExecutables(
     File sourcePackagePubspecFile,
     Directory sourcePackageRootDirectory,
   ) {
     final pubspecSyntax = PubspecYamlFile.loadSync(sourcePackagePubspecFile);

     final errors = pubspecSyntax.validateExecutables();
     if (errors.isNotEmpty) {
       _installException([
         'The pubspec.yaml contains the following errors:',
         ...errors
       ].join('\n'));
     }
     // This is a map of strings to string. Each key is the name of the command
     // that will be placed on the user's PATH. The value is the name of the
     // .dart script (without extension) in the package's `bin` directory that
     // should be run for that command. If the value is null, it defaults to the
     // key.
     final executablesSyntax = pubspecSyntax.executables;
     if (executablesSyntax == null) {
       _installException('The pubspec.yaml contained no executables section.');
     }
     if (executablesSyntax.isEmpty) {
       _installException(
           'The pubspec.yaml executables section contained no executables.');
     }

     return [
       for (final executable in executablesSyntax.entries)
         (
           name: executable.key,
           sourceEntryPoint: sourcePackageRootDirectory.uri
               .resolve('bin/${executable.value ?? executable.key}.dart')
         )
     ];
   }

   Future<void> _doBuild(
     DartBuildExecutables executables,
     Directory buildDirectory,
     File helperPackageConfigFile,
     File sourcePackagePubspecFile,
   ) async {
     // TODO(https://github.com/dart-lang/native/issues/2465): Add a test for
     // user-defines in the source package pubspec.
     final buildResult = await BuildCliSubcommand.doBuild(
       executables: executables,
       enabledExperiments: [],
       outputUri: buildDirectory.uri,
       packageConfigUri: helperPackageConfigFile.uri,
       pubspecUri: sourcePackagePubspecFile.uri,
       recordUseEnabled: false,
       verbose: verbose,
       verbosity: 'all',
     );
     if (buildResult != 0) {
       _installException('Build failed.', exitCode: buildResult);
     }
   }

   void _uniinstallAllPackageVersions(String packageName) {
     final bundles =
         DartInstallDirectory().allAppBundlesSync(packageName: packageName);

     try {
       for (final bundle in bundles) {
         print('Uninstalling ${bundle.directory.path}.');
         final links = bundle.executablesOnPathSync;
         for (final link in links) {
           print('Deleting ${link.entity.path}');
           link.deleteSync();
         }
         print('Deleting ${bundle.directory.path}');
         bundle.directory.deleteSync(recursive: true);
       }
     } on PathAccessException {
       _installException('Deletion failed. The application might be in use.');
     }
   }

   AppBundleDirectory _selectAppBundleDirectory(
     _InstallCommandParsedArguments parsedArgs,
     String packageName,
     Directory helperPackageDir,
     File helperPackageLockFile,
   ) {
     final AppBundleDirectory outputDir;
     switch (parsedArgs.sourceKind) {
       case _SourceKind.git:
         final resolvedGitRef = parsedArgs.gitRef ??
             GitPackageDescriptionSyntax.fromJson(
               PubspecLockFile.loadSync(helperPackageLockFile)
                   .packages![packageName]!
                   .description
                   .json,
             ).resolvedRef;
         outputDir = DartInstallDirectory().gitAppBundle(
           packageName,
           resolvedGitRef,
         );
       case _SourceKind.hosted:
         final packageGraphJson = PackageGraphFile.loadSync(File.fromUri(
           helperPackageDir.uri.resolve('.dart_tool/package_graph.json'),
         ));
         final resolvedVersion = packageGraphJson.packages
             .firstWhere((e) => e.name == packageName)
             .version;
         outputDir = DartInstallDirectory().hostedAppBundle(
           packageName,
           resolvedVersion,
         );
       case _SourceKind.path:
         outputDir = DartInstallDirectory().localAppBundle(packageName);
     }
     return outputDir;
   }

   Future<void> _createAppBundleDirectory(
       AppBundleDirectory appBundleDirectory,
       Directory buildDirectory,
       File helperPackageLockFile,
       File sourcePackagePubspecFile) async {
     if (appBundleDirectory.directory.existsSync()) {
       try {
         appBundleDirectory.directory.deleteSync(recursive: true);
       } on PathAccessException {
         _installException(
           'Failed to delete: ${appBundleDirectory.directory.path}. '
           'The application might be in use.',
         );
       }
     }
     appBundleDirectory.directory.createSync(recursive: true);
     final bundleDirectory =
         Directory.fromUri(buildDirectory.uri.resolve('bundle/'));
     await bundleDirectory.rename(
         appBundleDirectory.directory.uri.resolve('bundle/').toFilePath());
     await helperPackageLockFile.copy(appBundleDirectory.pubspecLock.path);
     await sourcePackagePubspecFile.copy(appBundleDirectory.pubspec.path);
   }

   void _installExecutablesOnPath(
       DartBuildExecutables executables,
       AppBundleDirectory appBundleDirectory,
       String packageName,
       _InstallCommandParsedArguments parsedArgs) {
     final errors = <String>[];
     for (final executable in executables) {
       final executableName = executable.name;
       final executableFile = appBundleDirectory.executable(executableName);
       final executableOnPath =
           DartInstallDirectory().bin.executable(executableName);
       var createLink = true;

       if (executableOnPath.existsSync()) {
         final targetExecutable = executableOnPath.targetSync();
         final targetPackageName = targetExecutable.appBundle.tryPackageName;
         if (targetPackageName == null ||
             targetPackageName == packageName ||
             parsedArgs.overwrite) {
           try {
             executableOnPath.deleteSync();
           } on PathAccessException {
             _installException(
               'Failed to delete: ${executableOnPath.entity.path}. '
               'The application might be in use.',
             );
           }
         } else {
           errors.add(
             'Refusing to overwrite executable $executableName from package:$targetPackageName. '
             'Pass --overwrite to override.',
           );
           createLink = false;
         }
       }
       if (createLink) {
         executableOnPath.createSync(executableFile);
         print('Installed: ${executableOnPath.entity.path}');
       }
     }
     if (errors.isNotEmpty) {
       _installException(errors.join('\n'));
     }
   }

   /// Checks to see if the binstubs are on the user's PATH and, if not, suggests
   /// that the user add the directory to their PATH.
   ///
   /// [installed] should be the name of an installed executable that can be used
   /// to test whether accessing it on the path works.
   static void _suggestIfNotOnPath(String installed) {
     final binDirPath = DartInstallDirectory().bin.directory.path;
     if (Platform.isWindows) {
       // See if the shell can find one of the binstubs.
       // "\q" means return exit code 0 if found or 1 if not.
       final result = Process.runSync('where', [r'\q', '$installed.bat']);
       if (result.exitCode == 0) return;

       stdout.writeln(
         'Warning: Dart installs executables into '
         '$binDirPath, which is not on your path.\n'
         "You can fix that by adding that directory to your system's "
         '"Path" environment variable.\n'
         'A web search for "configure windows path" will show you how.',
       );
     } else {
       // See if the shell can find one of the binstubs.
       //
       // The "command" builtin is more reliable than the "which" executable. See
       // http://unix.stackexchange.com/questions/85249/why-not-use-which-what-to-use-then
       final result = Process.runSync(
         'command',
         [
           '-v',
           installed,
         ],
         runInShell: true,
       );
       if (result.exitCode == 0) return;

       var binDir = binDirPath;
       if (binDir.startsWith(Platform.environment['HOME']!)) {
         binDir = p.join(
           r'$HOME',
           p.relative(binDir, from: Platform.environment['HOME']),
         );
       }
       final shellConfigFiles = Platform.isMacOS
           // zsh is default on mac - mention that first.
           ? '(.zshrc, .bashrc, .bash_profile, etc.)'
           : '(.bashrc, .bash_profile, .zshrc, etc.)';
       stdout.writeln(
         "'Warning: Dart installs executables into "
         '$binDir, which is not on your path.\n'
         "You can fix that by adding this to your shell's config file "
         '$shellConfigFiles:\n'
         '\n'
         '  export PATH="\$PATH":"$binDir"\n'
         '\n',
       );
     }
   }

   @override
   Future<int> run() async {
     final parsedArgs = _parseArguments();
     final packageName = await _findPackageName(parsedArgs);
     return await _inTempDir((tempDirectory) async {
       try {
         final helperPackageDirectory =
             Directory.fromUri(tempDirectory.uri.resolve('helperPackage/'));
         helperPackageDirectory.createSync();
         _createHelperPackagePubspec(
           helperPackageDir: helperPackageDirectory,
           packageName: packageName,
           parsedArgs: parsedArgs,
         );
         await _resolveHelperPackage(helperPackageDirectory);

         final helperPackageLockFile =
             File.fromUri(helperPackageDirectory.uri.resolve('pubspec.lock'));
         final helperPackageConfigFile = File.fromUri(helperPackageDirectory.uri
             .resolve('.dart_tool/package_config.json'));

         final sourcePackageRootDirectory = Directory(Uri.parse(
           PackageConfigFile.loadSync(helperPackageConfigFile)
               .packages
               .firstWhere((e) => e.name == packageName)
               .rootUri,
         ).toFilePath())
             .ensureEndWithSeparator;

         final sourcePackagePubspecFile = File.fromUri(
             sourcePackageRootDirectory.uri.resolve('pubspec.yaml'));

         final executables = _loadDeclaredExecutables(
           sourcePackagePubspecFile,
           sourcePackageRootDirectory,
         );

         final buildDirectory =
             Directory.fromUri(tempDirectory.uri.resolve('build/'));
         await _doBuild(
           executables,
           buildDirectory,
           helperPackageConfigFile,
           sourcePackagePubspecFile,
         );

         _uniinstallAllPackageVersions(packageName);

         AppBundleDirectory appBundleDirectory = _selectAppBundleDirectory(
           parsedArgs,
           packageName,
           helperPackageDirectory,
           helperPackageLockFile,
         );
         await _createAppBundleDirectory(
           appBundleDirectory,
           buildDirectory,
           helperPackageLockFile,
           sourcePackagePubspecFile,
         );

         _installExecutablesOnPath(
           executables,
           appBundleDirectory,
           packageName,
           parsedArgs,
         );
         _suggestIfNotOnPath(executables.first.name);
       } on _InstallException catch (e) {
         stderr.writeln(e.message);
         return genericErrorExitCode;
       }

       return 0;
     });
   }

   /// Throws a [_InstallException] with [message].
   ///
   /// This enables similar coding style to using [usageException]s.
   Never _installException(String message, {int? exitCode}) =>
       throw _InstallException(message, exitCode: exitCode);

   static Future<T> _inTempDir<T>(
       Future<T> Function(Directory tempDirectory) fun) async {
     final tempDir = await Directory.systemTemp.createTemp();
     // Deal with Windows temp folder aliases.
     final tempDirResolved = Directory.fromUri(
       Directory(await tempDir.resolveSymbolicLinks()).uri.normalizePath(),
     );
     try {
       return await fun(tempDirResolved);
     } finally {
       try {
         await tempDir.delete(recursive: true);
       } on PathAccessException {
         if (Platform.isWindows) {
           // Don't fail on Windows having files in use.
         } else {
           rethrow;
         }
       }
     }
   }
 }

 final class _InstallCommandParsedArguments {
   final String source;
   final _SourceKind sourceKind;
   final String? versionConstraint;
   final String? gitPath;
   final String? gitRef;
   final String? hostedUrl;
   final bool overwrite;

   _InstallCommandParsedArguments._({
     required this.source,
     required this.sourceKind,
     required this.versionConstraint,
     required this.gitPath,
     required this.gitRef,
     required this.hostedUrl,
     required this.overwrite,
   });
 }

 enum _SourceKind {
   git,
   hosted,
   path;

   static _SourceKind fromArgument(String argument) {
     if (_packageNameRegExp.hasMatch(argument)) {
       return hosted;
     }
     final parsedUri = Uri.tryParse(argument);
     if (parsedUri != null) {
       switch (parsedUri.scheme.toLowerCase()) {
         case 'git':
         case 'http':
         case 'https':
           return git;
       }
     }
     final parsedGitSshUrl = _GitSshUrl.tryParse(argument);
     if (parsedGitSshUrl != null) {
       return git;
     }
     return path;
   }

   /// A regular expression matching a Dart identifier.
   ///
   /// This also matches a package name, since they must be Dart identifiers.
   static final _identifierRegExp = RegExp(r'[a-zA-Z_]\w*');

   /// A regular expression matching allowed package names.
   ///
   /// This allows dot-separated valid Dart identifiers. The dots are there for
   /// compatibility with Google's internal Dart packages, but they may not be used
   /// when publishing a package to pub.dev.
   static final _packageNameRegExp = RegExp(
     '^${_identifierRegExp.pattern}(\\.${_identifierRegExp.pattern})*\$',
   );
 }

 // Expected format: git@host:owner/repository.git
 class _GitSshUrl {
   final String user;
   final String host;
   final String owner;
   final String repository;
   final String fullUrl;

   _GitSshUrl({
     required this.user,
     required this.host,
     required this.owner,
     required this.repository,
     required this.fullUrl,
   });

   static _GitSshUrl? tryParse(String url) {
     final regex = RegExp(r'^(\w+)@([^:]+):([^/]+)/(.+?)(?:\.git)?$');
     final match = regex.firstMatch(url);

     if (match == null) {
       return null;
     }

     return _GitSshUrl(
       user: match.group(1)!,
       host: match.group(2)!,
       owner: match.group(3)!,
       repository: match.group(4)!,
       fullUrl: url,
     );
   }

   @override
   String toString() {
     return 'GitSshUrl(user: $user, host: $host, owner: $owner, repository: $repository, fullUrl: $fullUrl)';
   }
 }

 /// An exception during the installation process.
 class _InstallException implements Exception {
   final String message;
   final int? exitCode;

   _InstallException(
     this.message, {
     this.exitCode,
   });

   @override
   String toString() => message;
 }
	// Copyright (c) 2025, the Dart project authors. Please see the AUTHORS file
	// for details. 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';

	import 'package:dartdev/src/commands/build.dart';
	import 'package:dartdev/src/install/file_system.dart';
	import 'package:dartdev/src/install/pub_formats.dart';
	import 'package:path/path.dart' as p;
	import 'package:pub/pub.dart';
	import 'package:pub_formats/pub_formats.dart';

	import '../core.dart';

	class InstallCommand extends DartdevCommand {
	static const cmdName = 'install';
	static const cmdDescription =
	'''Install or upgrade a Dart CLI tool for global use.

	Install all executables specified in a package's pubspec.yaml executables
	section (https://dart.dev/tools/pub/pubspec#executables) on the PATH. If the
	executables section doesn't exist, installs all `bin/*.dart` entry points as
	executables.

	If the same package has been previously installed, it will be overwritten.

	You can specify three different values for the <package> argument:
	1. A package name. This will install the package from pub.dev. (hosted)
	The [version-constraint] argument can only be passed to 'hosted'.
	2. A git url. This will install the package from a git repository. (git)
	3. A path on your machine. This will install the package from that path. (path)''';
	static const int genericErrorExitCode = 255;

	@override
	String get invocation {
	final superNoArguments = super.invocation.replaceAll(' [arguments]', '');
	return '$superNoArguments <package> [version-constraint]';
	}

	@override
	CommandCategory get commandCategory => CommandCategory.global;

	InstallCommand({bool verbose = false})
	: super(cmdName, cmdDescription, verbose) {
	argParser.addOption(
	'git-path',
	help: 'Path of git package in repository. '
	'Only applies when using a git url for <package>.',
	);

	argParser.addOption(
	'git-ref',
	help: 'Git branch or commit to be retrieved. '
	'Only applies when using a git url for <package>.',
	);

	argParser.addFlag(
	'overwrite',
	negatable: false,
	help: 'Overwrite executables from other packages with the same name.',
	);

	argParser.addOption(
	'hosted-url',
	abbr: 'u',
	help: 'A custom pub server URL for the package. '
	'Only applies when using a package name for <package>.',
	);
	}

	/// Parses the arguments.
	///
	/// Reports usage errors to user if the wrong number or arguments or the wrong
	/// flags are passed.
	_InstallCommandParsedArguments _parseArguments() {
	final argResults = this.argResults!;

	final overwrite = argResults.flag('overwrite');

	Iterable<String> args = argResults.rest;

	String readArg([String error = '']) {
	if (args.isEmpty) usageException(error);
	final arg = args.first;
	args = args.skip(1);
	return arg;
	}

	final argument = readArg('No package source given.');
	final sourceKind = _SourceKind.fromArgument(argument);

	final gitPath = argResults.option('git-path');
	var gitRef = argResults.option('git-ref');
	if (sourceKind != _SourceKind.git && (gitPath != null \|\| gitRef != null)) {
	usageException(
	'Options `--git-path` and `--git-ref` '
	'can only be used with a git source.',
	);
	}

	final hostedUrl = argResults.option('hosted-url');
	if (sourceKind != _SourceKind.hosted && hostedUrl != null) {
	usageException(
	'Option `--hosted-url` can only be used with a hosted source.',
	);
	}

	String? versionConstraint;
	switch (sourceKind) {
	case _SourceKind.git:
	case _SourceKind.path:
	break;
	case _SourceKind.hosted:
	versionConstraint = args.isEmpty ? 'any' : readArg();
	}
	if (args.isNotEmpty) {
	usageException(
	'Too many arguments, did not expect "${args.join(' ')}"',
	);
	}
	return _InstallCommandParsedArguments._(
	source: argument,
	sourceKind: sourceKind,
	versionConstraint: versionConstraint,
	gitPath: gitPath,
	gitRef: gitRef,
	hostedUrl: hostedUrl,
	overwrite: overwrite,
	);
	}

	Future<String> _findPackageName(
	_InstallCommandParsedArguments parsedArgs,
	) async {
	switch (parsedArgs.sourceKind) {
	case _SourceKind.git:
	return await getPackageNameFromGitRepo(
	parsedArgs.source,
	ref: parsedArgs.gitRef,
	path: parsedArgs.gitPath,
	relativeTo: Directory.current.path,
	tagPattern: null,
	);
	case _SourceKind.hosted:
	return parsedArgs.source;
	case _SourceKind.path:
	final pubspecFile = File.fromUri(
	Directory(parsedArgs.source).absolute.uri.resolve('pubspec.yaml'));
	if (!await pubspecFile.exists()) {
	usageException('No pubspec found in ${pubspecFile.path}.');
	}
	final pubspecYaml = PubspecYamlFile.loadSync(pubspecFile);
	return pubspecYaml.name;
	}
	}

	/// Creates a helper package to pull in the requested package as a dependency.
	///
	/// The user provides us either with (1) a package name plus optional version
	/// constraint, (2) a git repo, or (3) a local path. In order to avoid
	/// reimplementing pub's knowledge about how to pull in (1) and (2), we create
	/// a package with a dependency on the package that the user wants to install.
	/// Subsequently, we run `pub get` to let pub pull in dependencies, and we use
	/// the `package_graph.json` to find the root of the package that was pulled
	/// in by pub.
	void _createHelperPackagePubspec({
	required _InstallCommandParsedArguments parsedArgs,
	required String packageName,
	required Directory helperPackageDir,
	}) {
	final tempPubspec =
	File.fromUri(helperPackageDir.uri.resolve('pubspec.yaml'));
	final helperPackagePubspec = PubspecYamlFileSyntax(
	name: _helperPackageName,
	environment: EnvironmentSyntax(
	sdk: '^${Platform.version.split(' ').first}',
	),
	dependencies: {
	packageName: switch (parsedArgs.sourceKind) {
	_SourceKind.git => GitDependencySourceSyntax(
	git: GitSyntax(
	url: parsedArgs.source,
	path$: parsedArgs.gitPath,
	ref: parsedArgs.gitRef,
	),
	),
	_SourceKind.hosted => HostedDependencySourceSyntax(
	hosted: parsedArgs.hostedUrl,
	version: parsedArgs.versionConstraint!,
	),
	_SourceKind.path =>
	// Re-resolve dependencies for path activate, behave like it would work
	// for users of the package if the activate via hosted or git.
	PathDependencySourceSyntax(
	path$: Directory(parsedArgs.source).absolute.path,
	),
	}
	},
	);
	helperPackagePubspec.writeSync(tempPubspec);
	}

	static const _helperPackageName = 'dart_install_helper_package';

	Future<void> _resolveHelperPackage(Directory helperPackageDir) async {
	try {
	await ensurePubspecResolved(helperPackageDir.path);
	} on ResolutionFailedException catch (e) {
	_installException(e.message);
	}
	}

	/// The executables that should be placed on the user's PATH when this
	/// package is installed.
	DartBuildExecutables _loadDeclaredExecutables(
	File sourcePackagePubspecFile,
	Directory sourcePackageRootDirectory,
	) {
	final pubspecSyntax = PubspecYamlFile.loadSync(sourcePackagePubspecFile);

	final errors = pubspecSyntax.validateExecutables();
	if (errors.isNotEmpty) {
	_installException([
	'The pubspec.yaml contains the following errors:',
	...errors
	].join('\n'));
	}
	// This is a map of strings to string. Each key is the name of the command
	// that will be placed on the user's PATH. The value is the name of the
	// .dart script (without extension) in the package's `bin` directory that
	// should be run for that command. If the value is null, it defaults to the
	// key.
	final executablesSyntax = pubspecSyntax.executables;
	if (executablesSyntax == null) {
	_installException('The pubspec.yaml contained no executables section.');
	}
	if (executablesSyntax.isEmpty) {
	_installException(
	'The pubspec.yaml executables section contained no executables.');
	}

	return [
	for (final executable in executablesSyntax.entries)
	(
	name: executable.key,
	sourceEntryPoint: sourcePackageRootDirectory.uri
	.resolve('bin/${executable.value ?? executable.key}.dart')
	)
	];
	}

	Future<void> _doBuild(
	DartBuildExecutables executables,
	Directory buildDirectory,
	File helperPackageConfigFile,
	File sourcePackagePubspecFile,
	) async {
	// TODO(https://github.com/dart-lang/native/issues/2465): Add a test for
	// user-defines in the source package pubspec.
	final buildResult = await BuildCliSubcommand.doBuild(
	executables: executables,
	enabledExperiments: [],
	outputUri: buildDirectory.uri,
	packageConfigUri: helperPackageConfigFile.uri,
	pubspecUri: sourcePackagePubspecFile.uri,
	recordUseEnabled: false,
	verbose: verbose,
	verbosity: 'all',
	);
	if (buildResult != 0) {
	_installException('Build failed.', exitCode: buildResult);
	}
	}

	void _uniinstallAllPackageVersions(String packageName) {
	final bundles =
	DartInstallDirectory().allAppBundlesSync(packageName: packageName);

	try {
	for (final bundle in bundles) {
	print('Uninstalling ${bundle.directory.path}.');
	final links = bundle.executablesOnPathSync;
	for (final link in links) {
	print('Deleting ${link.entity.path}');
	link.deleteSync();
	}
	print('Deleting ${bundle.directory.path}');
	bundle.directory.deleteSync(recursive: true);
	}
	} on PathAccessException {
	_installException('Deletion failed. The application might be in use.');
	}
	}

	AppBundleDirectory _selectAppBundleDirectory(
	_InstallCommandParsedArguments parsedArgs,
	String packageName,
	Directory helperPackageDir,
	File helperPackageLockFile,
	) {
	final AppBundleDirectory outputDir;
	switch (parsedArgs.sourceKind) {
	case _SourceKind.git:
	final resolvedGitRef = parsedArgs.gitRef ??
	GitPackageDescriptionSyntax.fromJson(
	PubspecLockFile.loadSync(helperPackageLockFile)
	.packages![packageName]!
	.description
	.json,
	).resolvedRef;
	outputDir = DartInstallDirectory().gitAppBundle(
	packageName,
	resolvedGitRef,
	);
	case _SourceKind.hosted:
	final packageGraphJson = PackageGraphFile.loadSync(File.fromUri(
	helperPackageDir.uri.resolve('.dart_tool/package_graph.json'),
	));
	final resolvedVersion = packageGraphJson.packages
	.firstWhere((e) => e.name == packageName)
	.version;
	outputDir = DartInstallDirectory().hostedAppBundle(
	packageName,
	resolvedVersion,
	);
	case _SourceKind.path:
	outputDir = DartInstallDirectory().localAppBundle(packageName);
	}
	return outputDir;
	}

	Future<void> _createAppBundleDirectory(
	AppBundleDirectory appBundleDirectory,
	Directory buildDirectory,
	File helperPackageLockFile,
	File sourcePackagePubspecFile) async {
	if (appBundleDirectory.directory.existsSync()) {
	try {
	appBundleDirectory.directory.deleteSync(recursive: true);
	} on PathAccessException {
	_installException(
	'Failed to delete: ${appBundleDirectory.directory.path}. '
	'The application might be in use.',
	);
	}
	}
	appBundleDirectory.directory.createSync(recursive: true);
	final bundleDirectory =
	Directory.fromUri(buildDirectory.uri.resolve('bundle/'));
	await bundleDirectory.rename(
	appBundleDirectory.directory.uri.resolve('bundle/').toFilePath());
	await helperPackageLockFile.copy(appBundleDirectory.pubspecLock.path);
	await sourcePackagePubspecFile.copy(appBundleDirectory.pubspec.path);
	}

	void _installExecutablesOnPath(
	DartBuildExecutables executables,
	AppBundleDirectory appBundleDirectory,
	String packageName,
	_InstallCommandParsedArguments parsedArgs) {
	final errors = <String>[];
	for (final executable in executables) {
	final executableName = executable.name;
	final executableFile = appBundleDirectory.executable(executableName);
	final executableOnPath =
	DartInstallDirectory().bin.executable(executableName);
	var createLink = true;

	if (executableOnPath.existsSync()) {
	final targetExecutable = executableOnPath.targetSync();
	final targetPackageName = targetExecutable.appBundle.tryPackageName;
	if (targetPackageName == null \|\|
	targetPackageName == packageName \|\|
	parsedArgs.overwrite) {
	try {
	executableOnPath.deleteSync();
	} on PathAccessException {
	_installException(
	'Failed to delete: ${executableOnPath.entity.path}. '
	'The application might be in use.',
	);
	}
	} else {
	errors.add(
	'Refusing to overwrite executable $executableName from package:$targetPackageName. '
	'Pass --overwrite to override.',
	);
	createLink = false;
	}
	}
	if (createLink) {
	executableOnPath.createSync(executableFile);
	print('Installed: ${executableOnPath.entity.path}');
	}
	}
	if (errors.isNotEmpty) {
	_installException(errors.join('\n'));
	}
	}

	/// Checks to see if the binstubs are on the user's PATH and, if not, suggests
	/// that the user add the directory to their PATH.
	///
	/// [installed] should be the name of an installed executable that can be used
	/// to test whether accessing it on the path works.
	static void _suggestIfNotOnPath(String installed) {
	final binDirPath = DartInstallDirectory().bin.directory.path;
	if (Platform.isWindows) {
	// See if the shell can find one of the binstubs.
	// "\q" means return exit code 0 if found or 1 if not.
	final result = Process.runSync('where', [r'\q', '$installed.bat']);
	if (result.exitCode == 0) return;

	stdout.writeln(
	'Warning: Dart installs executables into '
	'$binDirPath, which is not on your path.\n'
	"You can fix that by adding that directory to your system's "
	'"Path" environment variable.\n'
	'A web search for "configure windows path" will show you how.',
	);
	} else {
	// See if the shell can find one of the binstubs.
	//
	// The "command" builtin is more reliable than the "which" executable. See
	// http://unix.stackexchange.com/questions/85249/why-not-use-which-what-to-use-then
	final result = Process.runSync(
	'command',
	[
	'-v',
	installed,
	],
	runInShell: true,
	);
	if (result.exitCode == 0) return;

	var binDir = binDirPath;
	if (binDir.startsWith(Platform.environment['HOME']!)) {
	binDir = p.join(
	r'$HOME',
	p.relative(binDir, from: Platform.environment['HOME']),
	);
	}
	final shellConfigFiles = Platform.isMacOS
	// zsh is default on mac - mention that first.
	? '(.zshrc, .bashrc, .bash_profile, etc.)'
	: '(.bashrc, .bash_profile, .zshrc, etc.)';
	stdout.writeln(
	"'Warning: Dart installs executables into "
	'$binDir, which is not on your path.\n'
	"You can fix that by adding this to your shell's config file "
	'$shellConfigFiles:\n'
	'\n'
	' export PATH="\$PATH":"$binDir"\n'
	'\n',
	);
	}
	}

	@override
	Future<int> run() async {
	final parsedArgs = _parseArguments();
	final packageName = await _findPackageName(parsedArgs);
	return await _inTempDir((tempDirectory) async {
	try {
	final helperPackageDirectory =
	Directory.fromUri(tempDirectory.uri.resolve('helperPackage/'));
	helperPackageDirectory.createSync();
	_createHelperPackagePubspec(
	helperPackageDir: helperPackageDirectory,
	packageName: packageName,
	parsedArgs: parsedArgs,
	);
	await _resolveHelperPackage(helperPackageDirectory);

	final helperPackageLockFile =
	File.fromUri(helperPackageDirectory.uri.resolve('pubspec.lock'));
	final helperPackageConfigFile = File.fromUri(helperPackageDirectory.uri
	.resolve('.dart_tool/package_config.json'));

	final sourcePackageRootDirectory = Directory(Uri.parse(
	PackageConfigFile.loadSync(helperPackageConfigFile)
	.packages
	.firstWhere((e) => e.name == packageName)
	.rootUri,
	).toFilePath())
	.ensureEndWithSeparator;

	final sourcePackagePubspecFile = File.fromUri(
	sourcePackageRootDirectory.uri.resolve('pubspec.yaml'));

	final executables = _loadDeclaredExecutables(
	sourcePackagePubspecFile,
	sourcePackageRootDirectory,
	);

	final buildDirectory =
	Directory.fromUri(tempDirectory.uri.resolve('build/'));
	await _doBuild(
	executables,
	buildDirectory,
	helperPackageConfigFile,
	sourcePackagePubspecFile,
	);

	_uniinstallAllPackageVersions(packageName);

	AppBundleDirectory appBundleDirectory = _selectAppBundleDirectory(
	parsedArgs,
	packageName,
	helperPackageDirectory,
	helperPackageLockFile,
	);
	await _createAppBundleDirectory(
	appBundleDirectory,
	buildDirectory,
	helperPackageLockFile,
	sourcePackagePubspecFile,
	);

	_installExecutablesOnPath(
	executables,
	appBundleDirectory,
	packageName,
	parsedArgs,
	);
	_suggestIfNotOnPath(executables.first.name);
	} on _InstallException catch (e) {
	stderr.writeln(e.message);
	return genericErrorExitCode;
	}

	return 0;
	});
	}

	/// Throws a [_InstallException] with [message].
	///
	/// This enables similar coding style to using [usageException]s.
	Never _installException(String message, {int? exitCode}) =>
	throw _InstallException(message, exitCode: exitCode);

	static Future<T> _inTempDir<T>(
	Future<T> Function(Directory tempDirectory) fun) async {
	final tempDir = await Directory.systemTemp.createTemp();
	// Deal with Windows temp folder aliases.
	final tempDirResolved = Directory.fromUri(
	Directory(await tempDir.resolveSymbolicLinks()).uri.normalizePath(),
	);
	try {
	return await fun(tempDirResolved);
	} finally {
	try {
	await tempDir.delete(recursive: true);
	} on PathAccessException {
	if (Platform.isWindows) {
	// Don't fail on Windows having files in use.
	} else {
	rethrow;
	}
	}
	}
	}
	}

	final class _InstallCommandParsedArguments {
	final String source;
	final _SourceKind sourceKind;
	final String? versionConstraint;
	final String? gitPath;
	final String? gitRef;
	final String? hostedUrl;
	final bool overwrite;

	_InstallCommandParsedArguments._({
	required this.source,
	required this.sourceKind,
	required this.versionConstraint,
	required this.gitPath,
	required this.gitRef,
	required this.hostedUrl,
	required this.overwrite,
	});
	}

	enum _SourceKind {
	git,
	hosted,
	path;

	static _SourceKind fromArgument(String argument) {
	if (_packageNameRegExp.hasMatch(argument)) {
	return hosted;
	}
	final parsedUri = Uri.tryParse(argument);
	if (parsedUri != null) {
	switch (parsedUri.scheme.toLowerCase()) {
	case 'git':
	case 'http':
	case 'https':
	return git;
	}
	}
	final parsedGitSshUrl = _GitSshUrl.tryParse(argument);
	if (parsedGitSshUrl != null) {
	return git;
	}
	return path;
	}

	/// A regular expression matching a Dart identifier.
	///
	/// This also matches a package name, since they must be Dart identifiers.
	static final _identifierRegExp = RegExp(r'[a-zA-Z_]\w*');

	/// A regular expression matching allowed package names.
	///
	/// This allows dot-separated valid Dart identifiers. The dots are there for
	/// compatibility with Google's internal Dart packages, but they may not be used
	/// when publishing a package to pub.dev.
	static final _packageNameRegExp = RegExp(
	'^${_identifierRegExp.pattern}(\\.${_identifierRegExp.pattern})*\$',
	);
	}

	// Expected format: git@host:owner/repository.git
	class _GitSshUrl {
	final String user;
	final String host;
	final String owner;
	final String repository;
	final String fullUrl;

	_GitSshUrl({
	required this.user,
	required this.host,
	required this.owner,
	required this.repository,
	required this.fullUrl,
	});

	static _GitSshUrl? tryParse(String url) {
	final regex = RegExp(r'^(\w+)@([^:]+):([^/]+)/(.+?)(?:\.git)?$');
	final match = regex.firstMatch(url);

	if (match == null) {
	return null;
	}

	return _GitSshUrl(
	user: match.group(1)!,
	host: match.group(2)!,
	owner: match.group(3)!,
	repository: match.group(4)!,
	fullUrl: url,
	);
	}

	@override
	String toString() {
	return 'GitSshUrl(user: $user, host: $host, owner: $owner, repository: $repository, fullUrl: $fullUrl)';
	}
	}

	/// An exception during the installation process.
	class _InstallException implements Exception {
	final String message;
	final int? exitCode;

	_InstallException(
	this.message, {
	this.exitCode,
	});

	@override
	String toString() => message;
	}