Defang Agent

pkgs/defang/cli.nix

@@ -7,7 +7,7 @@ buildGo124Module {
   pname = "defang-cli";
   version = "git";
   src = lib.cleanSource ../../src;
-  vendorHash = "sha256-le/O0WhOXO8ItgiG1ZRqDzMNV/2mOwWATn8T/xfn6dM="; # TODO: use fetchFromGitHub
+  vendorHash = "sha256-/1a2G+8JQUYhMv2zHlhDoDsFLXhxA//AwVfIWw5fqeo="; # TODO: use fetchFromGitHub
 
   subPackages = [ "cmd/cli" ];
 

src/cmd/cli/command/commands.go

@@ -15,12 +15,14 @@ import (
 
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/DefangLabs/defang/src/pkg"
+	"github.com/DefangLabs/defang/src/pkg/agent"
 	"github.com/DefangLabs/defang/src/pkg/cli"
 	cliClient "github.com/DefangLabs/defang/src/pkg/cli/client"
 	"github.com/DefangLabs/defang/src/pkg/cli/client/byoc"
 	"github.com/DefangLabs/defang/src/pkg/cli/client/byoc/gcp"
 	"github.com/DefangLabs/defang/src/pkg/cli/compose"
 	"github.com/DefangLabs/defang/src/pkg/clouds/aws"
+	"github.com/DefangLabs/defang/src/pkg/debug"
 	"github.com/DefangLabs/defang/src/pkg/dryrun"
 	"github.com/DefangLabs/defang/src/pkg/login"
 	"github.com/DefangLabs/defang/src/pkg/logs"
@@ -466,6 +468,24 @@ var RootCmd = &cobra.Command{
 
 		return err
 	},
+	RunE: func(cmd *cobra.Command, args []string) error {
+		if global.NonInteractive {
+			return cmd.Help()
+		}
+
+		ctx := cmd.Context()
+		err := login.InteractiveRequireLoginAndToS(ctx, global.Client, getCluster())
+		if err != nil {
+			return err
+		}
+
+		prompt := "Welcome to Defang. I can help you deploy your project to the cloud"
+		ag, err := agent.New(ctx, getCluster(), &global.ProviderID, &global.Stack)
+		if err != nil {
+			return err
+		}
+		return ag.StartWithUserPrompt(ctx, prompt)
+	},
 }
 
 var loginCmd = &cobra.Command{
@@ -912,6 +932,7 @@ var debugCmd = &cobra.Command{
 	Hidden:      true,
 	Short:       "Debug a build, deployment, or service failure",
 	RunE: func(cmd *cobra.Command, args []string) error {
+		ctx := cmd.Context()
 		etag, _ := cmd.Flags().GetString("etag")
 		deployment, _ := cmd.Flags().GetString("deployment")
 		since, _ := cmd.Flags().GetString("since")
@@ -922,12 +943,17 @@ var debugCmd = &cobra.Command{
 		}
 
 		loader := configureLoader(cmd)
-		provider, err := newProviderChecked(cmd.Context(), loader)
+		_, err := newProviderChecked(ctx, loader)
 		if err != nil {
 			return err
 		}
 
-		project, err := loader.LoadProject(cmd.Context())
+		project, err := loader.LoadProject(ctx)
+		if err != nil {
+			return err
+		}
+
+		debugger, err := debug.NewDebugger(ctx, getCluster(), &global.ProviderID, &global.Stack)
 		if err != nil {
 			return err
 		}
@@ -942,16 +968,15 @@ var debugCmd = &cobra.Command{
 			return fmt.Errorf("invalid 'until' time: %w", err)
 		}
 
-		debugConfig := cli.DebugConfig{
+		debugConfig := debug.DebugConfig{
 			Deployment:     deployment,
 			FailedServices: args,
-			ModelId:        global.ModelID,
 			Project:        project,
-			Provider:       provider,
+			ProviderID:     &global.ProviderID,
 			Since:          sinceTs.UTC(),
 			Until:          untilTs.UTC(),
 		}
-		return cli.DebugDeployment(cmd.Context(), global.Client, debugConfig)
+		return debugger.DebugDeployment(ctx, debugConfig)
 	},
 }
 

src/cmd/cli/command/compose.go

@@ -15,6 +15,7 @@ import (
 	cliClient "github.com/DefangLabs/defang/src/pkg/cli/client"
 	"github.com/DefangLabs/defang/src/pkg/cli/client/byoc"
 	"github.com/DefangLabs/defang/src/pkg/cli/compose"
+	"github.com/DefangLabs/defang/src/pkg/debug"
 	"github.com/DefangLabs/defang/src/pkg/dryrun"
 	"github.com/DefangLabs/defang/src/pkg/logs"
 	"github.com/DefangLabs/defang/src/pkg/modes"
@@ -67,8 +68,13 @@ func makeComposeUpCmd() *cobra.Command {
 					return err
 				}
 
-				track.Evt("Debug Prompted", P("loadErr", loadErr))
-				return cli.InteractiveDebugForClientError(ctx, global.Client, project, loadErr)
+				debugger, err := debug.NewDebugger(ctx, getCluster(), &global.ProviderID, &global.Stack)
+				if err != nil {
+					return err
+				}
+				return debugger.DebugComposeLoadError(ctx, debug.DebugConfig{
+					Project: project,
+				}, loadErr)
 			}
 
 			provider, err := newProviderChecked(ctx, loader)
@@ -137,7 +143,12 @@ func makeComposeUpCmd() *cobra.Command {
 				Mode:       global.Mode,
 			})
 			if err != nil {
-				return handleComposeUpErr(ctx, err, project, provider)
+				composeErr := err
+				debugger, err := debug.NewDebugger(ctx, getCluster(), &global.ProviderID, &global.Stack)
+				if err != nil {
+					return err
+				}
+				return handleComposeUpErr(ctx, debugger, project, provider, composeErr)
 			}
 
 			if len(deploy.Services) == 0 {
@@ -161,14 +172,21 @@ func makeComposeUpCmd() *cobra.Command {
 			tailOptions := newTailOptionsForDeploy(deploy.Etag, since, global.Verbose)
 			serviceStates, err := cli.TailAndMonitor(ctx, project, provider, time.Duration(waitTimeout)*time.Second, tailOptions)
 			if err != nil {
-				handleTailAndMonitorErr(ctx, err, global.Client, cli.DebugConfig{
+				deploymentErr := err
+				debugger, err := debug.NewDebugger(ctx, getCluster(), &global.ProviderID, &global.Stack)
+				if err != nil {
+					term.Warn("Failed to initialize debugger:", err)
+					return deploymentErr
+				}
+				handleTailAndMonitorErr(ctx, deploymentErr, debugger, debug.DebugConfig{
 					Deployment: deploy.Etag,
-					ModelId:    global.ModelID,
 					Project:    project,
-					Provider:   provider,
+					ProviderID: &global.ProviderID,
+					Stack:      &global.Stack,
 					Since:      since,
+					Until:      time.Now(),
 				})
-				return err
+				return deploymentErr
 			}
 
 			for _, service := range deploy.Services {
@@ -200,7 +218,7 @@ func makeComposeUpCmd() *cobra.Command {
 	return composeUpCmd
 }
 
-func handleComposeUpErr(ctx context.Context, err error, project *compose.Project, provider cliClient.Provider) error {
+func handleComposeUpErr(ctx context.Context, debugger *debug.Debugger, project *compose.Project, provider cliClient.Provider, err error) error {
 	if errors.Is(err, types.ErrComposeFileNotFound) {
 		// TODO: generate a compose file based on the current project
 		printDefangHint("To start a new project, do:", "new")
@@ -226,29 +244,30 @@ func handleComposeUpErr(ctx context.Context, err error, project *compose.Project
 	}
 
 	term.Error("Error:", cliClient.PrettyError(err))
-	track.Evt("Debug Prompted", P("composeErr", err))
-	return cli.InteractiveDebugForClientError(ctx, global.Client, project, err)
+	return debugger.DebugDeploymentError(ctx, debug.DebugConfig{
+		Project: project,
+	}, err)
 }
 
-func handleTailAndMonitorErr(ctx context.Context, err error, client *cliClient.GrpcClient, debugConfig cli.DebugConfig) {
+func handleTailAndMonitorErr(ctx context.Context, err error, debugger *debug.Debugger, debugConfig debug.DebugConfig) {
 	var errDeploymentFailed cliClient.ErrDeploymentFailed
 	if errors.As(err, &errDeploymentFailed) {
 		// Tail got canceled because of deployment failure: prompt to show the debugger
 		term.Warn(errDeploymentFailed)
 		if errDeploymentFailed.Service != "" {
 			debugConfig.FailedServices = []string{errDeploymentFailed.Service}
 		}
+
 		if global.NonInteractive {
 			printDefangHint("To debug the deployment, do:", debugConfig.String())
-		} else {
-			track.Evt("Debug Prompted", P("failedServices", debugConfig.FailedServices), P("etag", debugConfig.Deployment), P("reason", errDeploymentFailed))
+			return
+		}
 
-			// Call the AI debug endpoint using the original command context (not the tail ctx which is canceled)
-			if nil != cli.InteractiveDebugDeployment(ctx, client, debugConfig) {
-				// don't show this defang hint if debugging was successful
-				tailOptions := newTailOptionsForDeploy(debugConfig.Deployment, debugConfig.Since, true)
-				printDefangHint("To see the logs of the failed service, run:", "logs "+tailOptions.String())
-			}
+		// Call the AI debug endpoint using the original command context (not the tail ctx which is canceled)
+		if nil != debugger.DebugDeploymentError(ctx, debugConfig, errDeploymentFailed) {
+			// don't show this defang hint if debugging was successful
+			tailOptions := newTailOptionsForDeploy(debugConfig.Deployment, debugConfig.Since, true)
+			printDefangHint("To see the logs of the failed service, run:", "logs "+tailOptions.String())
 		}
 	}
 }
@@ -446,11 +465,19 @@ func makeComposeConfigCmd() *cobra.Command {
 				term.Error("Cannot load project:", loadErr)
 				project, err := loader.CreateProjectForDebug()
 				if err != nil {
-					return err
+					term.Warn("Failed to create project for debug:", err)
+					return loadErr
 				}
 
 				track.Evt("Debug Prompted", P("loadErr", loadErr))
-				return cli.InteractiveDebugForClientError(ctx, global.Client, project, loadErr)
+				debugger, err := debug.NewDebugger(ctx, getCluster(), &global.ProviderID, &global.Stack)
+				if err != nil {
+					term.Warn("Failed to initialize debugger:", err)
+					return loadErr
+				}
+				return debugger.DebugComposeLoadError(ctx, debug.DebugConfig{
+					Project: project,
+				}, loadErr)
 			}
 
 			provider, err := newProvider(ctx, loader)

src/cmd/cli/command/globals.go

@@ -1,17 +1,15 @@
 package command
 
 import (
-	"fmt"
 	"os"
-	"path/filepath"
 	"strconv"
 
 	cliClient "github.com/DefangLabs/defang/src/pkg/cli/client"
 	"github.com/DefangLabs/defang/src/pkg/cluster"
 	"github.com/DefangLabs/defang/src/pkg/migrate"
 	"github.com/DefangLabs/defang/src/pkg/modes"
+	"github.com/DefangLabs/defang/src/pkg/stacks"
 	"github.com/DefangLabs/defang/src/pkg/term"
-	"github.com/joho/godotenv"
 	"github.com/spf13/pflag"
 )
 
@@ -254,28 +252,10 @@ godotenv.Load respects existing environment variables. Stack-specific RC files
 are considered required when specified, while the general RC file is optional.
 */
 func (r *GlobalConfig) loadDotDefang(stackName string) error {
-	dotfile := ".defang"
 	if stackName != "" {
 		// If a stack name is provided, load the stack-specific RC file but return error if it fails or does not exist
-		dotfile = filepath.Join(dotfile, stackName)
-		if abs, err := filepath.Abs(dotfile); err == nil {
-			dotfile = abs
-		}
-		if err := godotenv.Load(dotfile); err != nil {
-			return fmt.Errorf("could not load stack %q: %w", stackName, err)
-		}
-	} else {
-		// If no stack name is provided, trying load the general .defang file
-		if abs, err := filepath.Abs(dotfile); err == nil {
-			dotfile = abs
-		}
-		// An error here is non-fatal since the file is optional
-		if err := godotenv.Load(dotfile); err != nil {
-			term.Debugf("could not load stack %q; continuing without env file: %v", stackName, err)
-			return nil // continue if no general env file
-		}
+		return stacks.Load(stackName) // ensure stack exists
 	}
 
-	term.Debugf("loaded globals from %s", dotfile)
 	return nil
 }

src/cmd/cli/command/globals_test.go

@@ -28,30 +28,6 @@ func Test_readGlobals(t *testing.T) {
 		os.Unsetenv("VALUE")
 	})
 
-	t.Run(".defang/test beats .defang", func(t *testing.T) {
-		t.Chdir("testdata/with-stack")
-		err := testConfig.loadDotDefang("test")
-		if err != nil {
-			t.Fatalf("%v", err)
-		}
-		if v := os.Getenv("VALUE"); v != "from .defang/test" {
-			t.Errorf("expected VALUE to be 'from .defang/test', got '%s'", v)
-		}
-		os.Unsetenv("VALUE")
-	})
-
-	t.Run(".defang used if no stack", func(t *testing.T) {
-		t.Chdir("testdata/no-stack")
-		err := testConfig.loadDotDefang("")
-		if err != nil {
-			t.Fatalf("%v", err)
-		}
-		if v := os.Getenv("VALUE"); v != "from .defang" {
-			t.Errorf("expected VALUE to be 'from .defang', got '%s'", v)
-		}
-		os.Unsetenv("VALUE")
-	})
-
 	t.Run("incorrect stackname used if no stack", func(t *testing.T) {
 		err := testConfig.loadDotDefang("non-existent-stack")
 		if err == nil {
@@ -245,41 +221,6 @@ func Test_configurationPrecedence(t *testing.T) {
 			},
 			expected: defaultConfig,
 		},
-		{
-			name:         "default .defang name, when no env vars or flags",
-			createRCFile: true,
-			rcStack: stack{
-				stackname: "",
-				entries: map[string]string{
-					"DEFANG_MODE":            "AFFORDABLE",
-					"DEFANG_VERBOSE":         "true",
-					"DEFANG_DEBUG":           "false",
-					"DEFANG_STACK":           "from-env",
-					"DEFANG_FABRIC":          "from-env-cluster",
-					"DEFANG_PROVIDER":        "defang",
-					"DEFANG_ORG":             "from-env-org",
-					"DEFANG_SOURCE_PLATFORM": "heroku",
-					"DEFANG_COLOR":           "always",
-					"DEFANG_TTY":             "false",
-					"DEFANG_NON_INTERACTIVE": "true",
-					"DEFANG_HIDE_UPDATE":     "true",
-				},
-			},
-			expected: GlobalConfig{
-				Mode:           modes.ModeAffordable, // env file values
-				Verbose:        true,
-				Debug:          false,
-				Stack:          "from-env",
-				Cluster:        "from-env-cluster",
-				ProviderID:     cliClient.ProviderDefang,
-				Org:            "from-env-org",
-				SourcePlatform: migrate.SourcePlatformHeroku,
-				ColorMode:      ColorAlways,
-				HasTty:         false, // from env
-				NonInteractive: true,  // from env
-				HideUpdate:     true,  // from env
-			},
-		},
 		{
 			name:         "default .defang name and no values, when no env vars or flags",
 			createRCFile: true,

src/cmd/cli/command/mcp.go

@@ -48,7 +48,11 @@ var mcpServerCmd = &cobra.Command{
 
 		// Create a new MCP server
 		term.Debug("Creating MCP server")
-		s, err := mcp.NewDefangMCPServer(RootCmd.Version, getCluster(), &global.ProviderID, mcpClient, tools.DefaultToolCLI{})
+		s, err := mcp.NewDefangMCPServer(RootCmd.Version, mcpClient, tools.DefaultToolCLI{}, mcp.StackConfig{
+			Cluster:    getCluster(),
+			ProviderID: &global.ProviderID,
+			Stack:      &global.Stack,
+		})
 		if err != nil {
 			return fmt.Errorf("failed to create MCP server: %w", err)
 		}