feat: kurtosis package init command

api/golang/core/lib/enclaves/kurtosis_yaml.go

@@ -17,6 +17,10 @@ type KurtosisYaml struct {
 	PackageReplaceOptions map[string]string `yaml:"replace"`
 }
 
+func NewKurtosisYaml(packageName string, packageDescription string, packageReplaceOptions map[string]string) *KurtosisYaml {
+	return &KurtosisYaml{PackageName: packageName, PackageDescription: packageDescription, PackageReplaceOptions: packageReplaceOptions}
+}
+
 func ParseKurtosisYaml(kurtosisYamlFilepath string) (*KurtosisYaml, error) {
 	kurtosisYamlContents, err := os.ReadFile(kurtosisYamlFilepath)
 	if err != nil {

core/server/api_container/server/startosis_engine/startosis_packages/git_package_content_provider/parsed_git_url.go → api/golang/core/lib/shared_utils/parsed_git_url.go

@@ -1,20 +1,20 @@
-package git_package_content_provider
+package shared_utils
 
 import (
 	"fmt"
-	"github.com/kurtosis-tech/kurtosis/core/server/api_container/server/startosis_engine/startosis_constants"
-	"github.com/kurtosis-tech/kurtosis/core/server/api_container/server/startosis_engine/startosis_errors"
+	"github.com/kurtosis-tech/stacktrace"
 	"net/url"
 	"path"
 	"strings"
 )
 
 const (
-	httpsSchema      = "https"
-	urlPathSeparator = "/"
-	// for a valid GitURl we need it to look like github.com/author/moduleName
+	GithubDomainPrefix = "github.com"
+	httpsSchema        = "https"
+	UrlPathSeparator   = "/"
+	//MinimumSubPathsForValidGitURL for a valid GitURl we need it to look like github.com/author/moduleName
 	// the last two are the minimum requirements for a valid Startosis URL
-	minimumSubPathsForValidGitURL = 2
+	MinimumSubPathsForValidGitURL = 2
 
 	tagBranchOrCommitDelimiter = "@"
 	emptyTagBranchOrCommit     = ""
@@ -54,44 +54,75 @@ func newParsedGitURL(moduleAuthor, moduleName, gitURL, relativeRepoPath, relativ
 	}
 }
 
-// parseGitURL this takes a Git url (GitHub) for now and converts it into the struct ParsedGitURL
+func (parsedUrl *ParsedGitURL) GetModuleAuthor() string {
+	return parsedUrl.moduleAuthor
+}
+
+func (parsedUrl *ParsedGitURL) GetModuleName() string {
+	return parsedUrl.moduleName
+}
+
+func (parsedUrl *ParsedGitURL) GetGitURL() string {
+	return parsedUrl.gitURL
+}
+
+func (parsedUrl *ParsedGitURL) GetRelativeRepoPath() string {
+	return parsedUrl.relativeRepoPath
+}
+
+func (parsedUrl *ParsedGitURL) GetRelativeFilePath() string {
+	return parsedUrl.relativeFilePath
+}
+
+func (parsedUrl *ParsedGitURL) GetTagBranchOrCommit() string {
+	return parsedUrl.tagBranchOrCommit
+}
+
+func (parsedUrl *ParsedGitURL) GetAbsoluteLocatorRelativeToThisURL(relativeUrl string) string {
+	if strings.HasPrefix(relativeUrl, packageRootPrefixIndicatorInRelativeLocators) {
+		return path.Join(GithubDomainPrefix, parsedUrl.relativeRepoPath, relativeUrl)
+	}
+	return path.Join(GithubDomainPrefix, path.Dir(parsedUrl.relativeFilePath), relativeUrl)
+}
+
+// ParseGitURL this takes a Git url (GitHub) for now and converts it into the struct ParsedGitURL
 // This can in the future be extended to GitLab or BitBucket or any other Git Host
-func parseGitURL(packageURL string) (*ParsedGitURL, *startosis_errors.InterpretationError) {
+func ParseGitURL(packageURL string) (*ParsedGitURL, error) {
 	// we expect something like github.com/author/module/path.star
 	// we don't want schemas
 	parsedURL, err := url.Parse(packageURL)
 	if err != nil {
-		return nil, startosis_errors.WrapWithInterpretationError(err, "Error parsing the URL of module '%v'", packageURL)
+		return nil, stacktrace.Propagate(err, "Error parsing the URL of module '%v'", packageURL)
 	}
 	if parsedURL.Scheme != "" {
-		return nil, startosis_errors.NewInterpretationError("Error parsing the URL of module '%v'. Expected schema to be empty got '%v'", packageURL, parsedURL.Scheme)
+		return nil, stacktrace.NewError("Error parsing the URL of module '%v'. Expected schema to be empty got '%v'", packageURL, parsedURL.Scheme)
 	}
 
 	// we prefix schema and make sure that the URL still parses
 	packageURLPrefixedWithHttps := httpsSchema + "://" + packageURL
 	parsedURL, err = url.Parse(packageURLPrefixedWithHttps)
 	if err != nil {
-		return nil, startosis_errors.WrapWithInterpretationError(err, "Error parsing the URL with scheme for module '%v'", packageURLPrefixedWithHttps)
+		return nil, stacktrace.Propagate(err, "Error parsing the URL with scheme for module '%v'", packageURLPrefixedWithHttps)
 	}
-	if parsedURL.Host != startosis_constants.GithubDomainPrefix {
-		return nil, startosis_errors.NewInterpretationError("Error parsing the URL of module. We only support modules on Github for now but got '%v'", packageURL)
+	if parsedURL.Host != GithubDomainPrefix {
+		return nil, stacktrace.NewError("Error parsing the URL of module. We only support modules on Github for now but got '%v'", packageURL)
 	}
 
 	pathWithoutVersion, maybeTagBranchOrCommit := parseOutTagBranchOrCommit(parsedURL.Path)
 
 	splitURLPath := cleanPathAndSplit(pathWithoutVersion)
 
-	if len(splitURLPath) < minimumSubPathsForValidGitURL {
-		return nil, startosis_errors.NewInterpretationError("Error parsing the URL of module: '%v'. The path should contain at least %d subpaths got '%v'", packageURL, minimumSubPathsForValidGitURL, splitURLPath)
+	if len(splitURLPath) < MinimumSubPathsForValidGitURL {
+		return nil, stacktrace.NewError("Error parsing the URL of module: '%v'. The path should contain at least %d subpaths got '%v'", packageURL, MinimumSubPathsForValidGitURL, splitURLPath)
 	}
 
 	moduleAuthor := splitURLPath[0]
 	moduleName := splitURLPath[1]
-	gitURL := fmt.Sprintf("%v://%v/%v/%v.git", httpsSchema, startosis_constants.GithubDomainPrefix, moduleAuthor, moduleName)
+	gitURL := fmt.Sprintf("%v://%v/%v/%v.git", httpsSchema, GithubDomainPrefix, moduleAuthor, moduleName)
 	relativeModulePath := path.Join(moduleAuthor, moduleName)
 
 	relativeFilePath := ""
-	if len(splitURLPath) > minimumSubPathsForValidGitURL {
+	if len(splitURLPath) > MinimumSubPathsForValidGitURL {
 		relativeFilePath = path.Join(splitURLPath...)
 	}
 
@@ -107,17 +138,10 @@ func parseGitURL(packageURL string) (*ParsedGitURL, *startosis_errors.Interpreta
 	return parsedGitURL, nil
 }
 
-func (parsedUrl *ParsedGitURL) getAbsoluteLocatorRelativeToThisURL(relativeUrl string) string {
-	if strings.HasPrefix(relativeUrl, packageRootPrefixIndicatorInRelativeLocators) {
-		return path.Join(startosis_constants.GithubDomainPrefix, parsedUrl.relativeRepoPath, relativeUrl)
-	}
-	return path.Join(startosis_constants.GithubDomainPrefix, path.Dir(parsedUrl.relativeFilePath), relativeUrl)
-}
-
 // cleanPath removes empty "" from the string slice
 func cleanPathAndSplit(urlPath string) []string {
 	cleanPath := path.Clean(urlPath)
-	splitPath := strings.Split(cleanPath, urlPathSeparator)
+	splitPath := strings.Split(cleanPath, UrlPathSeparator)
 	var sliceWithoutEmptyStrings []string
 	for _, subPath := range splitPath {
 		if subPath != "" {
@@ -138,7 +162,7 @@ func parseOutTagBranchOrCommit(input string) (string, string) {
 	// 3- github.com/kurtosis-tech/sample-dependency-package/main.star@foo/bar - here the tag is foo/bar;
 	// 4- github.com/kurtosis-tech/sample-dependency-package@foo/bar/mains.tar - here the tag is foo/bar; while file is /kurtosis-tech/sample-dependency-package/main.star
 	// we check if there is a file in maybeTagBranchOrCommitWithFile and then add it to pathWithoutVersion
-	maybeTagBranchOrCommit, lastSectionOfTagBranchCommitWithFile, _ := cutLast(maybeTagBranchOrCommitWithFile, urlPathSeparator)
+	maybeTagBranchOrCommit, lastSectionOfTagBranchCommitWithFile, _ := cutLast(maybeTagBranchOrCommitWithFile, UrlPathSeparator)
 
 	if lastSectionOfTagBranchCommitWithFile != "" && strings.Contains(lastSectionOfTagBranchCommitWithFile, extensionCharacter) {
 		// we assume pathWithoutVersion does not contain a file inside yet

core/server/api_container/server/startosis_engine/startosis_packages/git_package_content_provider/parsed_git_url_test.go → api/golang/core/lib/shared_utils/parsed_git_url_test.go

@@ -1,4 +1,4 @@
-package git_package_content_provider
+package shared_utils
 
 import (
 	"fmt"
@@ -18,7 +18,7 @@ const (
 )
 
 func TestParsedGitURL_SimpleParse(t *testing.T) {
-	parsedURL, err := parseGitURL(githubSampleURL)
+	parsedURL, err := ParseGitURL(githubSampleURL)
 	require.Nil(t, err)
 
 	expectedParsedURL := newParsedGitURL(
@@ -35,7 +35,7 @@ func TestParsedGitURL_SimpleParse(t *testing.T) {
 
 func TestParsedGitURL_FailsOnNonGithubURL(t *testing.T) {
 	nonGithubURL := "kurtosis-git.com/" + testModuleAuthor + "/" + testModuleName + "/" + testFileName
-	_, err := parseGitURL(nonGithubURL)
+	_, err := ParseGitURL(nonGithubURL)
 	require.NotNil(t, err)
 
 	expectedErrorMsg := "We only support modules on Github for now"
@@ -46,7 +46,7 @@ func TestParsedGitURL_FailsOnNonGithubURL(t *testing.T) {
 func TestParsedGitURL_FailsOnNonNonEmptySchema(t *testing.T) {
 	ftpSchema := "ftp"
 	nonGithubURL := ftpSchema + "://github.com/" + testModuleAuthor + "/" + testModuleName + "/" + testFileName
-	_, err := parseGitURL(nonGithubURL)
+	_, err := ParseGitURL(nonGithubURL)
 	require.NotNil(t, err)
 
 	expectedErrorMsg := fmt.Sprintf("Expected schema to be empty got '%v'", ftpSchema)
@@ -56,19 +56,19 @@ func TestParsedGitURL_FailsOnNonNonEmptySchema(t *testing.T) {
 
 func TestParsedGitURL_IfNoFileThenRelativeFilePathIsEmpty(t *testing.T) {
 	pathWithoutFile := "github.com/" + testModuleAuthor + "/" + testModuleName
-	parsedURL, err := parseGitURL(pathWithoutFile)
+	parsedURL, err := ParseGitURL(pathWithoutFile)
 	require.Nil(t, err)
 	require.Equal(t, "", parsedURL.relativeFilePath)
 }
 
 func TestParsedGitURL_ParsingGetsRidOfAnyPathEscapes(t *testing.T) {
 	escapedURLWithoutStartosisFile := "github.com/../etc/passwd"
-	parsedURL, err := parseGitURL(escapedURLWithoutStartosisFile)
+	parsedURL, err := ParseGitURL(escapedURLWithoutStartosisFile)
 	require.Nil(t, err)
 	require.Equal(t, "", parsedURL.relativeFilePath)
 
 	escapedURLWithStartosisFile := "github.com/../../etc/passwd/startosis.star"
-	parsedURL, err = parseGitURL(escapedURLWithStartosisFile)
+	parsedURL, err = ParseGitURL(escapedURLWithStartosisFile)
 	require.Nil(t, err)
 	require.Equal(t, parsedURL.moduleAuthor, "etc")
 	require.Equal(t, parsedURL.moduleName, "passwd")
@@ -77,7 +77,7 @@ func TestParsedGitURL_ParsingGetsRidOfAnyPathEscapes(t *testing.T) {
 	require.Equal(t, parsedURL.relativeRepoPath, "etc/passwd")
 
 	escapedURLWithStartosisFile = "github.com/foo/../etc/passwd/startosis.star"
-	parsedURL, err = parseGitURL(escapedURLWithStartosisFile)
+	parsedURL, err = ParseGitURL(escapedURLWithStartosisFile)
 	require.Nil(t, err)
 	require.Equal(t, parsedURL.moduleAuthor, "etc")
 	require.Equal(t, parsedURL.moduleName, "passwd")
@@ -86,14 +86,14 @@ func TestParsedGitURL_ParsingGetsRidOfAnyPathEscapes(t *testing.T) {
 	require.Equal(t, parsedURL.relativeRepoPath, "etc/passwd")
 
 	escapedURLWithStartosisFile = "github.com/foo/../etc/../passwd"
-	_, err = parseGitURL(escapedURLWithStartosisFile)
+	_, err = ParseGitURL(escapedURLWithStartosisFile)
 	require.NotNil(t, err)
 	expectedErrorMsg := fmt.Sprintf("Error parsing the URL of module: '%s'. The path should contain at least 2 subpaths got '[passwd]'", escapedURLWithStartosisFile)
 	require.Contains(t, err.Error(), expectedErrorMsg)
 }
 
 func TestParsedGitURL_WorksWithVersioningInformation(t *testing.T) {
-	parsedURL, err := parseGitURL(githubSampleUrlWithTag)
+	parsedURL, err := ParseGitURL(githubSampleUrlWithTag)
 	require.Nil(t, err)
 
 	expectedParsedURL := newParsedGitURL(
@@ -107,7 +107,7 @@ func TestParsedGitURL_WorksWithVersioningInformation(t *testing.T) {
 
 	require.Equal(t, expectedParsedURL, parsedURL)
 
-	parsedURL, err = parseGitURL(githubSampleUrlWithBranchContainingVersioningDelimiter)
+	parsedURL, err = ParseGitURL(githubSampleUrlWithBranchContainingVersioningDelimiter)
 	require.Nil(t, err)
 
 	expectedParsedURL = newParsedGitURL(
@@ -123,46 +123,46 @@ func TestParsedGitURL_WorksWithVersioningInformation(t *testing.T) {
 }
 
 func TestParsedGitUrl_ResolvesRelativeUrl(t *testing.T) {
-	parsedUrl, err := parseGitURL(githubSampleURL)
+	parsedUrl, err := ParseGitURL(githubSampleURL)
 	require.Nil(t, err)
 
 	relativeUrl := "./lib.star"
-	absoluteUrl := parsedUrl.getAbsoluteLocatorRelativeToThisURL(relativeUrl)
+	absoluteUrl := parsedUrl.GetAbsoluteLocatorRelativeToThisURL(relativeUrl)
 	require.Nil(t, err)
 	expected := "github.com/kurtosis-tech/sample-startosis-load/lib.star"
 	require.Equal(t, expected, absoluteUrl)
 
 	relativeUrl = "./src/lib.star"
-	absoluteUrl = parsedUrl.getAbsoluteLocatorRelativeToThisURL(relativeUrl)
+	absoluteUrl = parsedUrl.GetAbsoluteLocatorRelativeToThisURL(relativeUrl)
 	require.Nil(t, err)
 	expected = "github.com/kurtosis-tech/sample-startosis-load/src/lib.star"
 	require.Equal(t, expected, absoluteUrl)
 }
 
 func TestParsedGitUrl_ResolvesRelativeUrlForUrlWithTag(t *testing.T) {
-	parsedUrl, err := parseGitURL(githubSampleUrlWithTag)
+	parsedUrl, err := ParseGitURL(githubSampleUrlWithTag)
 	require.Nil(t, err)
 
 	relativeUrl := "./lib.star"
-	absoluteUrl := parsedUrl.getAbsoluteLocatorRelativeToThisURL(relativeUrl)
+	absoluteUrl := parsedUrl.GetAbsoluteLocatorRelativeToThisURL(relativeUrl)
 	require.Nil(t, err)
 	expected := "github.com/kurtosis-tech/sample-startosis-load/lib.star"
 	require.Equal(t, expected, absoluteUrl)
 
 	relativeUrl = "./src/lib.star"
-	absoluteUrl = parsedUrl.getAbsoluteLocatorRelativeToThisURL(relativeUrl)
+	absoluteUrl = parsedUrl.GetAbsoluteLocatorRelativeToThisURL(relativeUrl)
 	require.Nil(t, err)
 	expected = "github.com/kurtosis-tech/sample-startosis-load/src/lib.star"
 	require.Equal(t, expected, absoluteUrl)
 }
 
 func TestParsedGitUrl_ResolvesWithUrlWithVersionBranchWithSlash(t *testing.T) {
-	parsedUrl, err := parseGitURL(githubSampleUrlWithVersionWithSlash)
+	parsedUrl, err := ParseGitURL(githubSampleUrlWithVersionWithSlash)
 	require.Nil(t, err)
 
 	require.Equal(t, "foo/bar", parsedUrl.tagBranchOrCommit)
 
-	parsedUrl, err = parseGitURL(githubSampleUrlWithVersionWithSlashAndFile)
+	parsedUrl, err = ParseGitURL(githubSampleUrlWithVersionWithSlashAndFile)
 	require.Nil(t, err)
 	require.Equal(t, "foo/bar", parsedUrl.tagBranchOrCommit)
 	require.Equal(t, "kurtosis-tech/sample-startosis-load/main.star", parsedUrl.relativeFilePath)

cli/cli/command_str_consts/command_str_consts.go

@@ -70,6 +70,8 @@ const (
 	VersionCmdStr           = "version"
 	ImportCmdStr            = "import"
 	GatewayCmdStr           = "gateway"
+	PackageCmdStr           = "package"
+	InitCmdStr              = "init"
 	PortCmdStr              = "port"
 	PortPrintCmdStr         = "print"
 	WebCmdStr               = "web"

cli/cli/commands/package/init_cmd/init_cmd.go

@@ -0,0 +1,85 @@
+package init_cmd
+
+import (
+	"context"
+	"github.com/kurtosis-tech/kurtosis/api/golang/core/lib/shared_utils"
+	"github.com/kurtosis-tech/kurtosis/cli/cli/command_framework/lowlevel"
+	"github.com/kurtosis-tech/kurtosis/cli/cli/command_framework/lowlevel/args"
+	"github.com/kurtosis-tech/kurtosis/cli/cli/command_framework/lowlevel/flags"
+	"github.com/kurtosis-tech/kurtosis/cli/cli/command_str_consts"
+	"github.com/kurtosis-tech/kurtosis/cli/cli/kurtosis_package"
+	"github.com/kurtosis-tech/stacktrace"
+	"os"
+)
+
+const (
+	packageNameArgKey          = "package-name"
+	packageNameArgDefaultValue = ""
+	packageNameArgIsOptional   = false
+	packageNameArgIsGreedy     = false
+
+	executablePackageFlagKey          = "main"
+	executablePackageFlagDefaultValue = "false"
+)
+
+var InitCmd = &lowlevel.LowlevelKurtosisCommand{
+	CommandStr:       command_str_consts.InitCmdStr,
+	ShortDescription: "Creates a new Kurtosis package",
+	LongDescription:  "This command initializes the current directory to be a Kurtosis package by creating a `kurtosis.yml` with the given package name.",
+	Args: []*args.ArgConfig{
+		{
+			Key:            packageNameArgKey,
+			DefaultValue:   packageNameArgDefaultValue,
+			IsOptional:     packageNameArgIsOptional,
+			IsGreedy:       packageNameArgIsGreedy,
+			ValidationFunc: validatePackageNameArg,
+		},
+	},
+	Flags: []*flags.FlagConfig{
+		{
+			Key:     executablePackageFlagKey,
+			Usage:   "indicates that the created package is an executable package, and generates a 'main.star' if one does not already exist.",
+			Type:    flags.FlagType_Bool,
+			Default: executablePackageFlagDefaultValue,
+		},
+	},
+	PreValidationAndRunFunc:  nil,
+	RunFunc:                  run,
+	PostValidationAndRunFunc: nil,
+}
+
+func run(ctx context.Context, flags *flags.ParsedFlags, args *args.ParsedArgs) error {
+	packageNameArg, err := args.GetNonGreedyArg(packageNameArgKey)
+	if err != nil {
+		return stacktrace.Propagate(err, "an error occurred getting the value of argument with key '%v'", packageNameArgKey)
+	}
+
+	executablePackageFlag, err := flags.GetBool(executablePackageFlagKey)
+	if err != nil {
+		return stacktrace.Propagate(err, "an error occurred getting the value of flag '%v'", executablePackageFlagKey)
+	}
+
+	packageDestinationDirpath, err := os.Getwd()
+	if err != nil {
+		return stacktrace.Propagate(err, "An error occurred getting the current working directory for creating the Kurtosis package")
+	}
+
+	if err := kurtosis_package.InitializeKurtosisPackage(packageDestinationDirpath, packageNameArg, executablePackageFlag); err != nil {
+		return stacktrace.Propagate(err, "An error occurred initializing the Kurtosis package '%s' in '%s'", packageNameArg, packageDestinationDirpath)
+	}
+
+	return nil
+}
+
+func validatePackageNameArg(_ context.Context, _ *flags.ParsedFlags, args *args.ParsedArgs) error {
+	packageNameArg, err := args.GetNonGreedyArg(packageNameArgKey)
+	if err != nil {
+		return stacktrace.Propagate(err, "an error occurred getting the value of argument with key '%v'", packageNameArgKey)
+	}
+
+	if _, err := shared_utils.ParseGitURL(packageNameArg); err != nil {
+		return stacktrace.Propagate(err, "An erro occurred validating package name '%v', invalid GitHub URL", packageNameArg)
+	}
+
+	return nil
+}