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"
@@ -406,6 +408,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{
@@ -852,6 +872,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")
@@ -862,12 +883,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
 		}
@@ -882,16 +908,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"
@@ -160,14 +161,20 @@ 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 {
+					return err
+				}
+				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 {
@@ -229,25 +236,27 @@ func handleComposeUpErr(ctx context.Context, err error, project *compose.Project
 	return cli.InteractiveDebugForClientError(ctx, global.Client, 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())
-			}
+		track.Evt("Debug Prompted", P("failedServices", debugConfig.FailedServices), P("etag", debugConfig.Deployment), P("reason", errDeploymentFailed))
+
+		// Call the AI debug endpoint using the original command context (not the tail ctx which is canceled)
+		if nil != debugger.DebugDeployment(ctx, 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())
 		}
 	}
 }
@@ -448,8 +457,13 @@ func makeComposeConfigCmd() *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 := newProvider(ctx, loader)

src/cmd/cli/command/globals.go

@@ -1,7 +1,6 @@
 package command
 
 import (
-	"fmt"
 	"os"
 	"path/filepath"
 	"strconv"
@@ -10,6 +9,7 @@ import (
 	"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 +254,21 @@ 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
+	}
+	dotfile := ".defang"
+	// 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
 	}
-
 	term.Debugf("loaded globals from %s", dotfile)
+
 	return nil
 }

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)
 		}