Merge pull request #208 from dagger/cli-ux

CLI v2

cmd/dagger/cmd/common/common.go

@@ -0,0 +1,73 @@
+package common
+
+import (
+	"context"
+	"fmt"
+	"os"
+
+	"dagger.io/go/dagger"
+	"github.com/rs/zerolog/log"
+	"github.com/spf13/viper"
+)
+
+// getCurrentRoute returns the current selected route based on its abs path
+func GetCurrentRoute(ctx context.Context, store *dagger.Store) *dagger.Route {
+	lg := log.Ctx(ctx)
+	st := GetCurrentRouteState(ctx, store)
+
+	route, err := dagger.NewRoute(st)
+	if err != nil {
+		lg.
+			Fatal().
+			Err(err).
+			Interface("routeState", st).
+			Msg("failed to init route")
+	}
+
+	return route
+}
+
+func GetCurrentRouteState(ctx context.Context, store *dagger.Store) *dagger.RouteState {
+	lg := log.Ctx(ctx)
+
+	routeName := viper.GetString("route")
+	if routeName != "" {
+		st, err := store.LookupRouteByName(ctx, routeName)
+		if err != nil {
+			lg.
+				Fatal().
+				Err(err).
+				Str("routeName", routeName).
+				Msg("failed to lookup route by name")
+		}
+		return st
+	}
+
+	wd, err := os.Getwd()
+	if err != nil {
+		lg.Fatal().Err(err).Msg("cannot get current working directory")
+	}
+	st, err := store.LookupRouteByPath(ctx, wd)
+	if err != nil {
+		lg.
+			Fatal().
+			Err(err).
+			Str("routePath", wd).
+			Msg("failed to lookup route by path")
+	}
+	return st
+}
+
+func RouteUp(ctx context.Context, route *dagger.Route) {
+	lg := log.Ctx(ctx)
+
+	c, err := dagger.NewClient(ctx, "")
+	if err != nil {
+		lg.Fatal().Err(err).Msg("unable to create client")
+	}
+	output, err := c.Up(ctx, route)
+	if err != nil {
+		lg.Fatal().Err(err).Msg("failed to compute")
+	}
+	fmt.Println(output.JSON())
+}

cmd/dagger/cmd/compute.go

@@ -1,20 +1,22 @@
 package cmd
 
 import (
-	"fmt"
+	"encoding/json"
+	"errors"
+	"os"
+	"strings"
 
+	"dagger.io/go/cmd/dagger/cmd/common"
 	"dagger.io/go/cmd/dagger/logger"
 	"dagger.io/go/dagger"
+	"go.mozilla.org/sops"
+	"go.mozilla.org/sops/decrypt"
 
+	"github.com/google/uuid"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
 
-var (
-	input   *dagger.InputValue
-	updater *dagger.InputValue
-)
-
 var computeCmd = &cobra.Command{
 	Use:   "compute CONFIG",
 	Short: "Compute a configuration",
@@ -30,51 +32,116 @@ var computeCmd = &cobra.Command{
 		lg := logger.New()
 		ctx := lg.WithContext(cmd.Context())
 
-		env, err := dagger.NewEnv()
-		if err != nil {
-			lg.Fatal().Err(err).Msg("unable to initialize environment")
-		}
-		if err := updater.SourceFlag().Set(args[0]); err != nil {
-			lg.Fatal().Err(err).Msg("invalid local source")
+		st := &dagger.RouteState{
+			ID:           uuid.New().String(),
+			Name:         "FIXME",
+			LayoutSource: dagger.DirInput(args[0], []string{"*.cue", "cue.mod"}),
 		}
 
-		if err := env.SetUpdater(updater.Value()); err != nil {
-			lg.Fatal().Err(err).Msg("invalid updater script")
+		for _, input := range viper.GetStringSlice("input-string") {
+			parts := strings.SplitN(input, "=", 2)
+			k, v := parts[0], parts[1]
+			err := st.AddInput(k, dagger.TextInput(v))
+			if err != nil {
+				lg.
+					Fatal().
+					Err(err).
+					Str("input", k).
+					Msg("failed to add input")
+			}
 		}
-		if err := env.SetInput(input.Value()); err != nil {
-			lg.Fatal().Err(err).Msg("invalid input")
+
+		for _, input := range viper.GetStringSlice("input-dir") {
+			parts := strings.SplitN(input, "=", 2)
+			k, v := parts[0], parts[1]
+			err := st.AddInput(k, dagger.DirInput(v, []string{}))
+			if err != nil {
+				lg.
+					Fatal().
+					Err(err).
+					Str("input", k).
+					Msg("failed to add input")
+			}
 		}
-		c, err := dagger.NewClient(ctx, "")
+
+		for _, input := range viper.GetStringSlice("input-git") {
+			parts := strings.SplitN(input, "=", 2)
+			k, v := parts[0], parts[1]
+			err := st.AddInput(k, dagger.GitInput(v, "", ""))
+			if err != nil {
+				lg.
+					Fatal().
+					Err(err).
+					Str("input", k).
+					Msg("failed to add input")
+			}
+		}
+
+		if f := viper.GetString("input-json"); f != "" {
+			lg := lg.With().Str("path", f).Logger()
+
+			content, err := os.ReadFile(f)
+			if err != nil {
+				lg.Fatal().Err(err).Msg("failed to read file")
+			}
+
+			plaintext, err := decrypt.Data(content, "json")
+			if err != nil && !errors.Is(err, sops.MetadataNotFound) {
+				lg.Fatal().Err(err).Msg("unable to decrypt")
+			}
+
+			if len(plaintext) > 0 {
+				content = plaintext
+			}
+
+			if !json.Valid(content) {
+				lg.Fatal().Msg("invalid json")
+			}
+
+			err = st.AddInput("", dagger.JSONInput(string(content)))
+			if err != nil {
+				lg.Fatal().Err(err).Msg("failed to add input")
+			}
+		}
+
+		if f := viper.GetString("input-yaml"); f != "" {
+			lg := lg.With().Str("path", f).Logger()
+
+			content, err := os.ReadFile(f)
+			if err != nil {
+				lg.Fatal().Err(err).Msg("failed to read file")
+			}
+
+			plaintext, err := decrypt.Data(content, "yaml")
+			if err != nil && !errors.Is(err, sops.MetadataNotFound) {
+				lg.Fatal().Err(err).Msg("unable to decrypt")
+			}
+
+			if len(plaintext) > 0 {
+				content = plaintext
+			}
+
+			err = st.AddInput("", dagger.YAMLInput(string(content)))
+			if err != nil {
+				lg.Fatal().Err(err).Msg("failed to add input")
+			}
+		}
+
+		route, err := dagger.NewRoute(st)
 		if err != nil {
-			lg.Fatal().Err(err).Msg("unable to create client")
+			lg.Fatal().Err(err).Msg("unable to initialize route")
 		}
-		output, err := c.Compute(ctx, env)
-		if err != nil {
-			lg.Fatal().Err(err).Msg("failed to compute")
-		}
-		fmt.Println(output.JSON())
+
+		common.RouteUp(ctx, route)
 	},
 }
 
 func init() {
-	var err error
-	// Setup --input-* flags
-	input, err = dagger.NewInputValue("{}")
-	if err != nil {
-		panic(err)
-	}
-	computeCmd.Flags().Var(input.StringFlag(), "input-string", "TARGET=STRING")
-	computeCmd.Flags().Var(input.DirFlag(), "input-dir", "TARGET=PATH")
-	computeCmd.Flags().Var(input.GitFlag(), "input-git", "TARGET=REMOTE#REF")
-	computeCmd.Flags().Var(input.CueFlag(), "input-cue", "CUE")
-	computeCmd.Flags().Var(input.JSONFlag(), "input-json", "JSON")
-	computeCmd.Flags().Var(input.YAMLFlag(), "input-yaml", "YAML")
-
-	// Setup (future) --from-* flags
-	updater, err = dagger.NewInputValue("[...{do:string, ...}]")
-	if err != nil {
-		panic(err)
-	}
+	computeCmd.Flags().StringSlice("input-string", []string{}, "TARGET=STRING")
+	computeCmd.Flags().StringSlice("input-dir", []string{}, "TARGET=PATH")
+	computeCmd.Flags().StringSlice("input-git", []string{}, "TARGET=REMOTE#REF")
+	computeCmd.Flags().String("input-json", "", "JSON")
+	computeCmd.Flags().String("input-yaml", "", "YAML")
 
 	if err := viper.BindPFlags(computeCmd.Flags()); err != nil {
 		panic(err)

cmd/dagger/cmd/delete.go

@@ -0,0 +1,31 @@
+package cmd
+
+import (
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var deleteCmd = &cobra.Command{
+	Use:   "delete",
+	Short: "Delete a route after taking it offline (WARNING: may destroy infrastructure)",
+	Args:  cobra.NoArgs,
+	PreRun: func(cmd *cobra.Command, args []string) {
+		// Fix Viper bug for duplicate flags:
+		// https://github.com/spf13/viper/issues/233
+		if err := viper.BindPFlags(cmd.Flags()); err != nil {
+			panic(err)
+		}
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		// lg := logger.New()
+		// ctx := lg.WithContext(cmd.Context())
+
+		panic("not implemented")
+	},
+}
+
+func init() {
+	if err := viper.BindPFlags(deleteCmd.Flags()); err != nil {
+		panic(err)
+	}
+}

cmd/dagger/cmd/down.go

@@ -0,0 +1,52 @@
+package cmd
+
+import (
+	"dagger.io/go/cmd/dagger/cmd/common"
+	"dagger.io/go/cmd/dagger/logger"
+	"dagger.io/go/dagger"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var downCmd = &cobra.Command{
+	Use:   "down",
+	Short: "Take a route offline (WARNING: may destroy infrastructure)",
+	Args:  cobra.NoArgs,
+	PreRun: func(cmd *cobra.Command, args []string) {
+		// Fix Viper bug for duplicate flags:
+		// https://github.com/spf13/viper/issues/233
+		if err := viper.BindPFlags(cmd.Flags()); err != nil {
+			panic(err)
+		}
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		lg := logger.New()
+		ctx := lg.WithContext(cmd.Context())
+
+		store, err := dagger.DefaultStore()
+		if err != nil {
+			lg.Fatal().Err(err).Msg("failed to load store")
+		}
+
+		route := common.GetCurrentRoute(ctx, store)
+
+		// TODO: Implement options: --no-cache
+		if err := route.Down(ctx, nil); err != nil {
+			lg.
+				Fatal().
+				Err(err).
+				Str("routeName", route.Name()).
+				Str("routeId", route.ID()).
+				Msg("failed to up the route")
+		}
+	},
+}
+
+func init() {
+	downCmd.Flags().Bool("--no-cache", false, "Disable all run cache")
+
+	if err := viper.BindPFlags(downCmd.Flags()); err != nil {
+		panic(err)
+	}
+}

cmd/dagger/cmd/history.go

@@ -0,0 +1,31 @@
+package cmd
+
+import (
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var historyCmd = &cobra.Command{
+	Use:   "history",
+	Short: "List past changes to a route",
+	Args:  cobra.NoArgs,
+	PreRun: func(cmd *cobra.Command, args []string) {
+		// Fix Viper bug for duplicate flags:
+		// https://github.com/spf13/viper/issues/233
+		if err := viper.BindPFlags(cmd.Flags()); err != nil {
+			panic(err)
+		}
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		// lg := logger.New()
+		// ctx := lg.WithContext(cmd.Context())
+
+		panic("not implemented")
+	},
+}
+
+func init() {
+	if err := viper.BindPFlags(historyCmd.Flags()); err != nil {
+		panic(err)
+	}
+}

cmd/dagger/cmd/input/container.go

@@ -0,0 +1,33 @@
+package input
+
+import (
+	"dagger.io/go/cmd/dagger/logger"
+	"dagger.io/go/dagger"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var containerCmd = &cobra.Command{
+	Use:   "container TARGET CONTAINER-IMAGE",
+	Short: "Add a container image as input artifact",
+	Args:  cobra.ExactArgs(2),
+	PreRun: func(cmd *cobra.Command, args []string) {
+		// Fix Viper bug for duplicate flags:
+		// https://github.com/spf13/viper/issues/233
+		if err := viper.BindPFlags(cmd.Flags()); err != nil {
+			panic(err)
+		}
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		lg := logger.New()
+		ctx := lg.WithContext(cmd.Context())
+
+		updateRouteInput(ctx, args[0], dagger.DockerInput(args[1]))
+	},
+}
+
+func init() {
+	if err := viper.BindPFlags(containerCmd.Flags()); err != nil {
+		panic(err)
+	}
+}

cmd/dagger/cmd/input/dir.go

@@ -0,0 +1,33 @@
+package input
+
+import (
+	"dagger.io/go/cmd/dagger/logger"
+	"dagger.io/go/dagger"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var dirCmd = &cobra.Command{
+	Use:   "dir TARGET PATH",
+	Short: "Add a local directory as input artifact",
+	Args:  cobra.ExactArgs(2),
+	PreRun: func(cmd *cobra.Command, args []string) {
+		// Fix Viper bug for duplicate flags:
+		// https://github.com/spf13/viper/issues/233
+		if err := viper.BindPFlags(cmd.Flags()); err != nil {
+			panic(err)
+		}
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		lg := logger.New()
+		ctx := lg.WithContext(cmd.Context())
+
+		updateRouteInput(ctx, args[0], dagger.DirInput(args[1], []string{}))
+	},
+}
+
+func init() {
+	if err := viper.BindPFlags(dirCmd.Flags()); err != nil {
+		panic(err)
+	}
+}

cmd/dagger/cmd/input/git.go

@@ -0,0 +1,38 @@
+package input
+
+import (
+	"dagger.io/go/cmd/dagger/logger"
+	"dagger.io/go/dagger"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var gitCmd = &cobra.Command{
+	Use:   "git TARGET REMOTE REF [SUBDIR]",
+	Short: "Add a git repository as input artifact",
+	Args:  cobra.RangeArgs(3, 4),
+	PreRun: func(cmd *cobra.Command, args []string) {
+		// Fix Viper bug for duplicate flags:
+		// https://github.com/spf13/viper/issues/233
+		if err := viper.BindPFlags(cmd.Flags()); err != nil {
+			panic(err)
+		}
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		lg := logger.New()
+		ctx := lg.WithContext(cmd.Context())
+
+		subDir := ""
+		if len(args) > 3 {
+			subDir = args[3]
+		}
+
+		updateRouteInput(ctx, args[0], dagger.GitInput(args[1], args[2], subDir))
+	},
+}
+
+func init() {
+	if err := viper.BindPFlags(gitCmd.Flags()); err != nil {
+		panic(err)
+	}
+}

cmd/dagger/cmd/input/root.go

@@ -0,0 +1,43 @@
+package input
+
+import (
+	"context"
+
+	"dagger.io/go/cmd/dagger/cmd/common"
+	"dagger.io/go/dagger"
+	"github.com/rs/zerolog/log"
+	"github.com/spf13/cobra"
+)
+
+// Cmd exposes the top-level command
+var Cmd = &cobra.Command{
+	Use:   "input",
+	Short: "Manage a route's inputs",
+}
+
+func init() {
+	Cmd.AddCommand(
+		dirCmd,
+		gitCmd,
+		containerCmd,
+		secretCmd,
+		textCmd,
+	)
+}
+
+func updateRouteInput(ctx context.Context, target string, input dagger.Input) {
+	lg := log.Ctx(ctx)
+
+	store, err := dagger.DefaultStore()
+	if err != nil {
+		lg.Fatal().Err(err).Msg("failed to load store")
+	}
+
+	st := common.GetCurrentRouteState(ctx, store)
+	st.AddInput(target, input)
+
+	if err := store.UpdateRoute(ctx, st, nil); err != nil {
+		lg.Fatal().Err(err).Str("routeId", st.ID).Str("routeName", st.Name).Msg("cannot update route")
+	}
+	lg.Info().Str("routeId", st.ID).Str("routeName", st.Name).Msg("updated route")
+}

cmd/dagger/cmd/input/secret.go

@@ -0,0 +1,31 @@
+package input
+
+import (
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var secretCmd = &cobra.Command{
+	Use:   "secret TARGET VALUE",
+	Short: "Add an encrypted input secret",
+	Args:  cobra.ExactArgs(2),
+	PreRun: func(cmd *cobra.Command, args []string) {
+		// Fix Viper bug for duplicate flags:
+		// https://github.com/spf13/viper/issues/233
+		if err := viper.BindPFlags(cmd.Flags()); err != nil {
+			panic(err)
+		}
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		// lg := logger.New()
+		// ctx := lg.WithContext(cmd.Context())
+
+		panic("not implemented")
+	},
+}
+
+func init() {
+	if err := viper.BindPFlags(secretCmd.Flags()); err != nil {
+		panic(err)
+	}
+}

cmd/dagger/cmd/input/text.go

@@ -0,0 +1,33 @@
+package input
+
+import (
+	"dagger.io/go/cmd/dagger/logger"
+	"dagger.io/go/dagger"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var textCmd = &cobra.Command{
+	Use:   "text TARGET VALUE",
+	Short: "Add an input text",
+	Args:  cobra.ExactArgs(2),
+	PreRun: func(cmd *cobra.Command, args []string) {
+		// Fix Viper bug for duplicate flags:
+		// https://github.com/spf13/viper/issues/233
+		if err := viper.BindPFlags(cmd.Flags()); err != nil {
+			panic(err)
+		}
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		lg := logger.New()
+		ctx := lg.WithContext(cmd.Context())
+
+		updateRouteInput(ctx, args[0], dagger.TextInput(args[1]))
+	},
+}
+
+func init() {
+	if err := viper.BindPFlags(textCmd.Flags()); err != nil {
+		panic(err)
+	}
+}

cmd/dagger/cmd/layout/dir.go

@@ -0,0 +1,31 @@
+package layout
+
+import (
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var dirCmd = &cobra.Command{
+	Use:   "dir PATH",
+	Short: "Load layout from a local directory",
+	Args:  cobra.ExactArgs(1),
+	PreRun: func(cmd *cobra.Command, args []string) {
+		// Fix Viper bug for duplicate flags:
+		// https://github.com/spf13/viper/issues/233
+		if err := viper.BindPFlags(cmd.Flags()); err != nil {
+			panic(err)
+		}
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		// lg := logger.New()
+		// ctx := lg.WithContext(cmd.Context())
+
+		panic("not implemented")
+	},
+}
+
+func init() {
+	if err := viper.BindPFlags(dirCmd.Flags()); err != nil {
+		panic(err)
+	}
+}

cmd/dagger/cmd/layout/file.go

@@ -0,0 +1,31 @@
+package layout
+
+import (
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var fileCmd = &cobra.Command{
+	Use:   "file PATH|-",
+	Short: "Load layout from a cue file",
+	Args:  cobra.ExactArgs(1),
+	PreRun: func(cmd *cobra.Command, args []string) {
+		// Fix Viper bug for duplicate flags:
+		// https://github.com/spf13/viper/issues/233
+		if err := viper.BindPFlags(cmd.Flags()); err != nil {
+			panic(err)
+		}
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		// lg := logger.New()
+		// ctx := lg.WithContext(cmd.Context())
+
+		panic("not implemented")
+	},
+}
+
+func init() {
+	if err := viper.BindPFlags(fileCmd.Flags()); err != nil {
+		panic(err)
+	}
+}

cmd/dagger/cmd/layout/git.go

@@ -0,0 +1,31 @@
+package layout
+
+import (
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var gitCmd = &cobra.Command{
+	Use:   "git REMOTE REF [SUBDIR]",
+	Short: "Load layout from a git package",
+	Args:  cobra.MinimumNArgs(2),
+	PreRun: func(cmd *cobra.Command, args []string) {
+		// Fix Viper bug for duplicate flags:
+		// https://github.com/spf13/viper/issues/233
+		if err := viper.BindPFlags(cmd.Flags()); err != nil {
+			panic(err)
+		}
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		// lg := logger.New()
+		// ctx := lg.WithContext(cmd.Context())
+
+		panic("not implemented")
+	},
+}
+
+func init() {
+	if err := viper.BindPFlags(gitCmd.Flags()); err != nil {
+		panic(err)
+	}
+}

cmd/dagger/cmd/layout/package.go

@@ -0,0 +1,31 @@
+package layout
+
+import (
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var packageCmd = &cobra.Command{
+	Use:   "package PKG",
+	Short: "Load layout from a cue package",
+	Args:  cobra.ExactArgs(1),
+	PreRun: func(cmd *cobra.Command, args []string) {
+		// Fix Viper bug for duplicate flags:
+		// https://github.com/spf13/viper/issues/233
+		if err := viper.BindPFlags(cmd.Flags()); err != nil {
+			panic(err)
+		}
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		// lg := logger.New()
+		// ctx := lg.WithContext(cmd.Context())
+
+		panic("not implemented")
+	},
+}
+
+func init() {
+	if err := viper.BindPFlags(packageCmd.Flags()); err != nil {
+		panic(err)
+	}
+}

cmd/dagger/cmd/layout/root.go

@@ -0,0 +1,18 @@
+package layout
+
+import "github.com/spf13/cobra"
+
+// Cmd exposes the top-level command
+var Cmd = &cobra.Command{
+	Use:   "layout",
+	Short: "Manage a route's layout",
+}
+
+func init() {
+	Cmd.AddCommand(
+		packageCmd,
+		dirCmd,
+		gitCmd,
+		fileCmd,
+	)
+}

cmd/dagger/cmd/list.go

@@ -0,0 +1,49 @@
+package cmd
+
+import (
+	"fmt"
+
+	"dagger.io/go/cmd/dagger/logger"
+	"dagger.io/go/dagger"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var listCmd = &cobra.Command{
+	Use:   "list",
+	Short: "List available routes",
+	Args:  cobra.NoArgs,
+	PreRun: func(cmd *cobra.Command, args []string) {
+		// Fix Viper bug for duplicate flags:
+		// https://github.com/spf13/viper/issues/233
+		if err := viper.BindPFlags(cmd.Flags()); err != nil {
+			panic(err)
+		}
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		lg := logger.New()
+		ctx := lg.WithContext(cmd.Context())
+		store, err := dagger.DefaultStore()
+		if err != nil {
+			lg.Fatal().Err(err).Msg("failed to load store")
+		}
+
+		routes, err := store.ListRoutes(ctx)
+		if err != nil {
+			lg.
+				Fatal().
+				Err(err).
+				Msg("cannot list routes")
+		}
+
+		for _, r := range routes {
+			fmt.Println(r.Name)
+		}
+	},
+}
+
+func init() {
+	if err := viper.BindPFlags(listCmd.Flags()); err != nil {
+		panic(err)
+	}
+}

cmd/dagger/cmd/login.go

@@ -0,0 +1,31 @@
+package cmd
+
+import (
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var loginCmd = &cobra.Command{
+	Use:   "login",
+	Short: "Login to Dagger Cloud",
+	Args:  cobra.NoArgs,
+	PreRun: func(cmd *cobra.Command, args []string) {
+		// Fix Viper bug for duplicate flags:
+		// https://github.com/spf13/viper/issues/233
+		if err := viper.BindPFlags(cmd.Flags()); err != nil {
+			panic(err)
+		}
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		// lg := logger.New()
+		// ctx := lg.WithContext(cmd.Context())
+
+		panic("not implemented")
+	},
+}
+
+func init() {
+	if err := viper.BindPFlags(loginCmd.Flags()); err != nil {
+		panic(err)
+	}
+}

cmd/dagger/cmd/logout.go

@@ -0,0 +1,31 @@
+package cmd
+
+import (
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var logoutCmd = &cobra.Command{
+	Use:   "logout",
+	Short: "Logout from Dagger Cloud",
+	Args:  cobra.NoArgs,
+	PreRun: func(cmd *cobra.Command, args []string) {
+		// Fix Viper bug for duplicate flags:
+		// https://github.com/spf13/viper/issues/233
+		if err := viper.BindPFlags(cmd.Flags()); err != nil {
+			panic(err)
+		}
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		// lg := logger.New()
+		// ctx := lg.WithContext(cmd.Context())
+
+		panic("not implemented")
+	},
+}
+
+func init() {
+	if err := viper.BindPFlags(logoutCmd.Flags()); err != nil {
+		panic(err)
+	}
+}

cmd/dagger/cmd/new.go

@@ -0,0 +1,115 @@
+package cmd
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+
+	"dagger.io/go/cmd/dagger/cmd/common"
+	"dagger.io/go/cmd/dagger/logger"
+	"dagger.io/go/dagger"
+
+	"github.com/rs/zerolog/log"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var newCmd = &cobra.Command{
+	Use:   "new",
+	Short: "Create a new route",
+	Args:  cobra.NoArgs,
+	PreRun: func(cmd *cobra.Command, args []string) {
+		// Fix Viper bug for duplicate flags:
+		// https://github.com/spf13/viper/issues/233
+		if err := viper.BindPFlags(cmd.Flags()); err != nil {
+			panic(err)
+		}
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		lg := logger.New()
+		ctx := lg.WithContext(cmd.Context())
+		store, err := dagger.DefaultStore()
+		if err != nil {
+			lg.Fatal().Err(err).Msg("failed to load store")
+		}
+
+		st := &dagger.RouteState{
+			Name:         getNewRouteName(ctx),
+			LayoutSource: getLayoutSource(ctx),
+		}
+
+		err = store.CreateRoute(ctx, st)
+		if err != nil {
+			lg.Fatal().Err(err).Msg("failed to create route")
+		}
+		lg.
+			Info().
+			Str("routeId", st.ID).
+			Str("routeName", st.Name).
+			Msg("route created")
+
+		route, err := dagger.NewRoute(st)
+		if err != nil {
+			lg.
+				Fatal().
+				Err(err).
+				Msg("failed to initialize route")
+		}
+
+		if viper.GetBool("up") {
+			common.RouteUp(ctx, route)
+		}
+	},
+}
+
+func getNewRouteName(ctx context.Context) string {
+	lg := log.Ctx(ctx)
+
+	routeName := viper.GetString("route")
+	if routeName != "" {
+		return routeName
+	}
+
+	workDir, err := os.Getwd()
+	if err != nil {
+		lg.
+			Fatal().
+			Err(err).
+			Msg("failed to get current working dir")
+	}
+
+	currentDir := filepath.Base(workDir)
+	if currentDir == "/" {
+		return "root"
+	}
+
+	return currentDir
+}
+
+// FIXME: Implement options: --layout-*
+func getLayoutSource(ctx context.Context) dagger.Input {
+	lg := log.Ctx(ctx)
+
+	wd, err := os.Getwd()
+	if err != nil {
+		lg.Fatal().Err(err).Msg("cannot get current working directory")
+	}
+
+	return dagger.DirInput(wd, []string{"*.cue", "cue.mod"})
+}
+
+func init() {
+	newCmd.Flags().StringP("name", "n", "", "Specify a route name")
+	newCmd.Flags().BoolP("up", "u", false, "Bring the route online")
+
+	newCmd.Flags().String("layout-dir", "", "Load layout from a local directory")
+	newCmd.Flags().String("layout-git", "", "Load layout from a git repository")
+	newCmd.Flags().String("layout-package", "", "Load layout from a cue package")
+	newCmd.Flags().String("layout-file", "", "Load layout from a cue or json file")
+
+	newCmd.Flags().String("setup", "auto", "Specify whether to prompt user for initial setup (no|yes|auto)")
+
+	if err := viper.BindPFlags(newCmd.Flags()); err != nil {
+		panic(err)
+	}
+}

cmd/dagger/cmd/output/dir.go

@@ -0,0 +1,31 @@
+package output
+
+import (
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var dirCmd = &cobra.Command{
+	Use:   "dir PATH",
+	Short: "Add a local directory as output artifact",
+	Args:  cobra.ExactArgs(1),
+	PreRun: func(cmd *cobra.Command, args []string) {
+		// Fix Viper bug for duplicate flags:
+		// https://github.com/spf13/viper/issues/233
+		if err := viper.BindPFlags(cmd.Flags()); err != nil {
+			panic(err)
+		}
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		// lg := logger.New()
+		// ctx := lg.WithContext(cmd.Context())
+
+		panic("not implemented")
+	},
+}
+
+func init() {
+	if err := viper.BindPFlags(dirCmd.Flags()); err != nil {
+		panic(err)
+	}
+}

cmd/dagger/cmd/output/root.go

@@ -0,0 +1,15 @@
+package output
+
+import "github.com/spf13/cobra"
+
+// Cmd exposes the top-level command
+var Cmd = &cobra.Command{
+	Use:   "output",
+	Short: "Manage a route's outputs",
+}
+
+func init() {
+	Cmd.AddCommand(
+		dirCmd,
+	)
+}

cmd/dagger/cmd/query.go

@@ -0,0 +1,65 @@
+package cmd
+
+import (
+	"fmt"
+
+	"dagger.io/go/cmd/dagger/cmd/common"
+	"dagger.io/go/cmd/dagger/logger"
+	"dagger.io/go/dagger"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var queryCmd = &cobra.Command{
+	Use:   "query [EXPR] [flags]",
+	Short: "Query the contents of a route",
+	Args:  cobra.ExactArgs(1),
+	PreRun: func(cmd *cobra.Command, args []string) {
+		// Fix Viper bug for duplicate flags:
+		// https://github.com/spf13/viper/issues/233
+		if err := viper.BindPFlags(cmd.Flags()); err != nil {
+			panic(err)
+		}
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		lg := logger.New()
+		ctx := lg.WithContext(cmd.Context())
+
+		store, err := dagger.DefaultStore()
+		if err != nil {
+			lg.Fatal().Err(err).Msg("failed to load store")
+		}
+
+		route := common.GetCurrentRoute(ctx, store)
+
+		expr := args[0]
+
+		out, err := route.Query(ctx, expr, nil)
+		if err != nil {
+			lg.
+				Fatal().
+				Err(err).
+				Str("routeName", route.Name()).
+				Str("routeId", route.ID()).
+				Msg("failed to query route")
+		}
+
+		fmt.Println(out)
+		// TODO: Implement options: --no-*, --format, --revision
+
+	},
+}
+
+func init() {
+	queryCmd.Flags().String("revision", "latest", "Query a specific version of the route")
+	queryCmd.Flags().StringP("format", "f", "", "Output format (json|yaml|cue|text|env)")
+
+	queryCmd.Flags().BoolP("--no-input", "I", false, "Exclude inputs from query")
+	queryCmd.Flags().BoolP("--no-output", "O", false, "Exclude outputs from query")
+	queryCmd.Flags().BoolP("--no-layout", "L", false, "Exclude outputs from query")
+
+	if err := viper.BindPFlags(queryCmd.Flags()); err != nil {
+		panic(err)
+	}
+}

cmd/dagger/cmd/root.go

@@ -4,6 +4,9 @@ import (
 	"os"
 	"strings"
 
+	inputCmd "dagger.io/go/cmd/dagger/cmd/input"
+	"dagger.io/go/cmd/dagger/cmd/layout"
+	"dagger.io/go/cmd/dagger/cmd/output"
 	"dagger.io/go/cmd/dagger/logger"
 	"github.com/moby/buildkit/util/appcontext"
 	"github.com/opentracing/opentracing-go"
@@ -14,24 +17,28 @@ import (
 
 var rootCmd = &cobra.Command{
 	Use:   "dagger",
-	Short: "Open-source workflow engine",
+	Short: "A system for application delivery as code (ADC)",
 }
 
 func init() {
 	rootCmd.PersistentFlags().String("log-format", "", "Log format (json, pretty). Defaults to json if the terminal is not a tty")
 	rootCmd.PersistentFlags().StringP("log-level", "l", "debug", "Log level")
+	rootCmd.PersistentFlags().StringP("route", "r", "", "Select a route")
 
 	rootCmd.AddCommand(
 		computeCmd,
-		// Create an env
-		// Change settings on an env
-		// View or edit env serti
-		//		settingsCmd,
-		// Query the state of an env
-		//		getCmd,
-		//		unsetCmd,
-		//		computeCmd,
-		//		listCmd,
+		newCmd,
+		listCmd,
+		queryCmd,
+		upCmd,
+		downCmd,
+		deleteCmd,
+		historyCmd,
+		loginCmd,
+		logoutCmd,
+		layout.Cmd,
+		inputCmd.Cmd,
+		output.Cmd,
 	)
 
 	if err := viper.BindPFlags(rootCmd.PersistentFlags()); err != nil {

cmd/dagger/cmd/up.go

@@ -0,0 +1,44 @@
+package cmd
+
+import (
+	"dagger.io/go/cmd/dagger/cmd/common"
+	"dagger.io/go/cmd/dagger/logger"
+	"dagger.io/go/dagger"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var upCmd = &cobra.Command{
+	Use:   "up",
+	Short: "Bring a route online with latest layout and inputs",
+	Args:  cobra.NoArgs,
+	PreRun: func(cmd *cobra.Command, args []string) {
+		// Fix Viper bug for duplicate flags:
+		// https://github.com/spf13/viper/issues/233
+		if err := viper.BindPFlags(cmd.Flags()); err != nil {
+			panic(err)
+		}
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+		lg := logger.New()
+		ctx := lg.WithContext(cmd.Context())
+		store, err := dagger.DefaultStore()
+		if err != nil {
+			lg.Fatal().Err(err).Msg("failed to load store")
+		}
+
+		route := common.GetCurrentRoute(ctx, store)
+
+		// TODO: Implement options: --no-cache
+		common.RouteUp(ctx, route)
+	},
+}
+
+func init() {
+	newCmd.Flags().Bool("--no-cache", false, "Disable all run cache")
+
+	if err := viper.BindPFlags(upCmd.Flags()); err != nil {
+		panic(err)
+	}
+}