environment: install commands (#229)

* environment: install commands

Signed-off-by: Andrea Luzzardi <al@dagger.io>

* docs: install commands

Signed-off-by: Andrea Luzzardi <al@dagger.io>

* environment: load the uncommitted config

Signed-off-by: Andrea Luzzardi <al@dagger.io>

---------

Signed-off-by: Andrea Luzzardi <al@dagger.io>

Author: Andrea Luzzardi

cmd/container-use/config.go

@@ -123,6 +123,15 @@ container-use config show my-env
 			fmt.Fprintf(tw, "Setup Commands:\t(none)\n")
 		}
 
+		if len(config.InstallCommands) > 0 {
+			fmt.Fprintf(tw, "Install Commands:\t\n")
+			for i, cmd := range config.InstallCommands {
+				fmt.Fprintf(tw, "  %d.\t%s\n", i+1, cmd)
+			}
+		} else {
+			fmt.Fprintf(tw, "Install Commands:\t(none)\n")
+		}
+
 		envKeys := config.Env.Keys()
 		if len(envKeys) > 0 {
 			fmt.Fprintf(tw, "Environment Variables:\t\n")
@@ -316,6 +325,89 @@ var configSetupCommandClearCmd = &cobra.Command{
 	},
 }
 
+// Install command object commands
+var configInstallCommandCmd = &cobra.Command{
+	Use:   "install-command",
+	Short: "Manage install commands",
+	Long:  `Manage install commands that are run after copying code to environments.`,
+}
+
+var configInstallCommandAddCmd = &cobra.Command{
+	Use:   "add <command>",
+	Short: "Add an install command",
+	Long:  `Add a command to be run after copying code to new environments (e.g., "go mod download").`,
+	Args:  cobra.ExactArgs(1),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		command := args[0]
+		return updateConfig(cmd, func(config *environment.EnvironmentConfig) error {
+			config.InstallCommands = append(config.InstallCommands, command)
+			fmt.Printf("Install command added: %s\n", command)
+			return nil
+		})
+	},
+}
+
+var configInstallCommandRemoveCmd = &cobra.Command{
+	Use:   "remove <command>",
+	Short: "Remove an install command",
+	Long:  `Remove an install command from the environment configuration.`,
+	Args:  cobra.ExactArgs(1),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		command := args[0]
+		return updateConfig(cmd, func(config *environment.EnvironmentConfig) error {
+			found := false
+			newCommands := make([]string, 0, len(config.InstallCommands))
+			for _, existing := range config.InstallCommands {
+				if existing != command {
+					newCommands = append(newCommands, existing)
+				} else {
+					found = true
+				}
+			}
+
+			if !found {
+				return fmt.Errorf("install command not found: %s", command)
+			}
+
+			config.InstallCommands = newCommands
+			fmt.Printf("Install command removed: %s\n", command)
+			return nil
+		})
+	},
+}
+
+var configInstallCommandListCmd = &cobra.Command{
+	Use:   "list",
+	Short: "List all install commands",
+	Long:  `List all install commands that will be run after copying code to environments.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		return withConfig(cmd, func(config *environment.EnvironmentConfig) error {
+			if len(config.InstallCommands) == 0 {
+				fmt.Println("No install commands configured")
+				return nil
+			}
+
+			for i, command := range config.InstallCommands {
+				fmt.Printf("%d. %s\n", i+1, command)
+			}
+			return nil
+		})
+	},
+}
+
+var configInstallCommandClearCmd = &cobra.Command{
+	Use:   "clear",
+	Short: "Clear all install commands",
+	Long:  `Remove all install commands from the environment configuration.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		return updateConfig(cmd, func(config *environment.EnvironmentConfig) error {
+			config.InstallCommands = []string{}
+			fmt.Println("All install commands cleared")
+			return nil
+		})
+	},
+}
+
 // Environment variable object commands
 var configEnvCmd = &cobra.Command{
 	Use:   "env",
@@ -476,6 +568,12 @@ func init() {
 	configSetupCommandCmd.AddCommand(configSetupCommandListCmd)
 	configSetupCommandCmd.AddCommand(configSetupCommandClearCmd)
 
+	// Add install-command commands
+	configInstallCommandCmd.AddCommand(configInstallCommandAddCmd)
+	configInstallCommandCmd.AddCommand(configInstallCommandRemoveCmd)
+	configInstallCommandCmd.AddCommand(configInstallCommandListCmd)
+	configInstallCommandCmd.AddCommand(configInstallCommandClearCmd)
+
 	// Add env commands
 	configEnvCmd.AddCommand(configEnvSetCmd)
 	configEnvCmd.AddCommand(configEnvUnsetCmd)
@@ -491,6 +589,7 @@ func init() {
 	// Add object commands to config
 	configCmd.AddCommand(configBaseImageCmd)
 	configCmd.AddCommand(configSetupCommandCmd)
+	configCmd.AddCommand(configInstallCommandCmd)
 	configCmd.AddCommand(configEnvCmd)
 	configCmd.AddCommand(configSecretCmd)
 	configCmd.AddCommand(configShowCmd)

docs/environment-configuration.mdx

@@ -51,9 +51,12 @@ Set up a Python project environment:
 # Set the base image to Python 3.11
 container-use config base-image set python:3.11
 
-# Add setup commands for your project
-container-use config setup-command add "pip install -r requirements.txt"
-container-use config setup-command add "pip install pytest black flake8"
+# Add setup commands for system dependencies
+container-use config setup-command add "apt-get update && apt-get install -y build-essential"
+
+# Add install commands for project dependencies
+container-use config install-command add "pip install -r requirements.txt"
+container-use config install-command add "pip install pytest black flake8"
 
 # Set environment variables
 container-use config env set PYTHONPATH /workdir
@@ -134,12 +137,12 @@ container-use config base-image reset
 
 ## Setup Commands
 
-Setup commands are shell commands that run when creating a new environment, after the base image is ready but before the agent starts working.
+Setup commands run when creating a new environment, after pulling the base image but before copying your code. Use these for system-level dependencies and tools.
 
 ### Adding Setup Commands
 
 ```bash
-container-use config setup-command add "pip install -r requirements.txt"
+container-use config setup-command add "apt-get update && apt-get install -y build-essential"
 ```
 
 ### Managing Setup Commands
@@ -149,12 +152,36 @@ container-use config setup-command add "pip install -r requirements.txt"
 container-use config setup-command list
 
 # Remove a specific command
-container-use config setup-command remove "pip install pytest black flake8"
+container-use config setup-command remove "apt-get install -y build-essential"
 
 # Clear all setup commands
 container-use config setup-command clear
 ```
 
+## Install Commands
+
+Install commands run after copying your code to the environment. Use these for project dependencies and build steps.
+
+### Adding Install Commands
+
+```bash
+container-use config install-command add "go mod download"
+container-use config install-command add "npm install"
+```
+
+### Managing Install Commands
+
+```bash
+# List all install commands
+container-use config install-command list
+
+# Remove a specific command
+container-use config install-command remove "npm install"
+
+# Clear all install commands
+container-use config install-command clear
+```
+
 ## Environment Variables
 
 Environment variables are set in all new environments and can be used to configure your application, development tools, and runtime behavior.
@@ -207,9 +234,10 @@ Example output:
 Base Image:            python:3.11
 Workdir:               /workdir
 Setup Commands:
+  1.                   apt-get update && apt-get install -y build-essential
+Install Commands:
   1.                   pip install -r requirements.txt
   2.                   pip install pytest black flake8
-  3.                   ./scripts/dev-setup.sh
 Environment Variables:
   1.                   PYTHONPATH=/workdir
   2.                   DEBUG=true

environment/config.go

@@ -23,12 +23,13 @@ func DefaultConfig() *EnvironmentConfig {
 }
 
 type EnvironmentConfig struct {
-	Workdir       string         `json:"workdir,omitempty"`
-	BaseImage     string         `json:"base_image,omitempty"`
-	SetupCommands []string       `json:"setup_commands,omitempty"`
-	Env           KVList         `json:"env,omitempty"`
-	Secrets       KVList         `json:"secrets,omitempty"`
-	Services      ServiceConfigs `json:"services,omitempty"`
+	Workdir         string         `json:"workdir,omitempty"`
+	BaseImage       string         `json:"base_image,omitempty"`
+	SetupCommands   []string       `json:"setup_commands,omitempty"`
+	InstallCommands []string       `json:"install_commands,omitempty"`
+	Env             KVList         `json:"env,omitempty"`
+	Secrets         KVList         `json:"secrets,omitempty"`
+	Services        ServiceConfigs `json:"services,omitempty"`
 }
 
 type ServiceConfig struct {

environment/environment.go

@@ -31,12 +31,7 @@ type Environment struct {
 	mu sync.RWMutex
 }
 
-func New(ctx context.Context, dag *dagger.Client, id, title, worktree string, initialSourceDir *dagger.Directory) (*Environment, error) {
-	config := DefaultConfig()
-	if err := config.Load(worktree); err != nil {
-		return nil, err
-	}
-
+func New(ctx context.Context, dag *dagger.Client, id, title string, config *EnvironmentConfig, initialSourceDir *dagger.Directory) (*Environment, error) {
 	env := &Environment{
 		EnvironmentInfo: &EnvironmentInfo{
 			ID: id,
@@ -167,32 +162,41 @@ func (env *Environment) buildBase(ctx context.Context, baseSourceDir *dagger.Dir
 		return nil, err
 	}
 
-	for _, command := range env.State.Config.SetupCommands {
-		var err error
+	runCommands := func(commands []string) error {
+		for _, command := range commands {
+			var err error
 
-		container = container.WithExec([]string{"sh", "-c", command})
+			container = container.WithExec([]string{"sh", "-c", command})
 
-		exitCode, err := container.ExitCode(ctx)
-		if err != nil {
-			var exitErr *dagger.ExecError
-			if errors.As(err, &exitErr) {
-				env.Notes.AddCommand(command, exitErr.ExitCode, exitErr.Stdout, exitErr.Stderr)
-				return nil, fmt.Errorf("setup command failed with exit code %d.\nstdout: %s\nstderr: %s\n%w", exitErr.ExitCode, exitErr.Stdout, exitErr.Stderr, err)
+			exitCode, err := container.ExitCode(ctx)
+			if err != nil {
+				var exitErr *dagger.ExecError
+				if errors.As(err, &exitErr) {
+					env.Notes.AddCommand(command, exitErr.ExitCode, exitErr.Stdout, exitErr.Stderr)
+					return fmt.Errorf("exit code %d.\nstdout: %s\nstderr: %s\n%w", exitErr.ExitCode, exitErr.Stdout, exitErr.Stderr, err)
+				}
+
+				return err
+			}
+			stdout, err := container.Stdout(ctx)
+			if err != nil {
+				return fmt.Errorf("failed to get stdout: %w", err)
 			}
 
-			return nil, fmt.Errorf("failed to execute setup command: %w", err)
-		}
-		stdout, err := container.Stdout(ctx)
-		if err != nil {
-			return nil, fmt.Errorf("failed to get stdout: %w", err)
-		}
+			stderr, err := container.Stderr(ctx)
+			if err != nil {
+				return fmt.Errorf("failed to get stderr: %w", err)
+			}
 
-		stderr, err := container.Stderr(ctx)
-		if err != nil {
-			return nil, fmt.Errorf("failed to get stderr: %w", err)
+			env.Notes.AddCommand(command, exitCode, stdout, stderr)
 		}
 
-		env.Notes.AddCommand(command, exitCode, stdout, stderr)
+		return nil
+	}
+
+	// Run setup commands without the source directory for caching purposes
+	if err := runCommands(env.State.Config.SetupCommands); err != nil {
+		return nil, fmt.Errorf("setup command failed: %w", err)
 	}
 
 	env.Services, err = env.startServices(ctx)
@@ -205,6 +209,11 @@ func (env *Environment) buildBase(ctx context.Context, baseSourceDir *dagger.Dir
 
 	container = container.WithDirectory(".", baseSourceDir)
 
+	// Run the install commands after the source directory is set up
+	if err := runCommands(env.State.Config.InstallCommands); err != nil {
+		return nil, fmt.Errorf("install command failed: %w", err)
+	}
+
 	return container, nil
 }
 

environment/integration/integration_test.go

@@ -446,6 +446,27 @@ func TestEnvironmentConfigurationPersists(t *testing.T) {
 		})
 	})
 
+	t.Run("InstallCommandsPersist", func(t *testing.T) {
+		WithRepository(t, "install_commands", SetupNodeRepo, func(t *testing.T, repo *repository.Repository, user *UserActions) {
+			newEnv := user.CreateEnvironment("Test with install", "Creating environment with install commands")
+
+			installCmds := []string{
+				"npm install --save-dev jest",
+				"echo 'Dependencies installed' > /install.log",
+			}
+			updatedConfig := newEnv.State.Config.Copy()
+			updatedConfig.BaseImage = "node:18"
+			updatedConfig.InstallCommands = installCmds
+
+			user.UpdateEnvironment(newEnv.ID, "Test with install", "Install project dependencies", updatedConfig)
+
+			// Reload config
+			newEnv = user.GetEnvironment(newEnv.ID)
+			newConfig := newEnv.State.Config.Copy()
+			assert.Equal(t, installCmds, newConfig.InstallCommands, "Install commands should persist")
+		})
+	})
+
 	t.Run("EnvironmentVariable", func(t *testing.T) {
 		t.Run("Persistence", func(t *testing.T) {
 			WithRepository(t, "envvar_persistence", SetupNodeRepo, func(t *testing.T, repo *repository.Repository, user *UserActions) {

repository/repository.go

@@ -168,7 +168,12 @@ func (r *Repository) Create(ctx context.Context, dag *dagger.Client, description
 		return nil, fmt.Errorf("failed loading initial source directory: %w", err)
 	}
 
-	env, err := environment.New(ctx, dag, id, description, worktree, baseSourceDir)
+	config := environment.DefaultConfig()
+	if err := config.Load(r.userRepoPath); err != nil {
+		return nil, err
+	}
+
+	env, err := environment.New(ctx, dag, id, description, config, baseSourceDir)
 	if err != nil {
 		return nil, err
 	}