Native Windows Support (dagger#242)

* 1. signal handling

* 2. logger log path

* 3. get notify signal

* 4. repository.go

* 5. git

* 6. config.go

* 7. watch

* 8. config agent

* 9. docker daemon

* 10. completion

* 11. skip non compatible tests on Windows

* 12. smooth watch in windows

* 13. release: add windows support

Author: zhichli

.gitignore

@@ -1,5 +1,6 @@
 /cu
 /container-use
+/container-use.exe
 /completions/
 
 # Go targets

.goreleaser.yaml

@@ -18,6 +18,7 @@ builds:
     goos:
       - linux
       - darwin
+      - windows
     goarch:
       - amd64
       - arm64

cmd/container-use/agent/configure.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"runtime"
 	"strings"
 
 	"github.com/dagger/container-use/mcpserver"
@@ -71,6 +72,14 @@ type ConfigurableAgent interface {
 
 // Add agents here
 func selectAgent(agentKey string) (ConfigurableAgent, error) {
+	// Check if agent is supported on current platform
+	if runtime.GOOS == "windows" {
+		switch agentKey {
+		case "codex", "amazonq":
+			return nil, fmt.Errorf("agent '%s' is not supported on native Windows.\nTo use this agent, please install and run container-use in Windows Subsystem for Linux (WSL)", agentKey)
+		}
+	}
+
 	switch agentKey {
 	case "claude":
 		return &ConfigureClaude{}, nil

cmd/container-use/agent/configure_goose.go

@@ -5,6 +5,7 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"runtime"
 
 	"github.com/dagger/container-use/rules"
 	"github.com/mitchellh/go-homedir"
@@ -35,9 +36,23 @@ func (a *ConfigureGoose) description() string {
 
 // Save the MCP config with container-use enabled
 func (a *ConfigureGoose) editMcpConfig() error {
-	configPath, err := homedir.Expand(filepath.Join("~", ".config", "goose", "config.yaml"))
-	if err != nil {
-		return err
+	var configPath string
+	var err error
+
+	if runtime.GOOS == "windows" {
+		// Windows: %APPDATA%\Block\goose\config\config.yaml
+		// Reference: https://block.github.io/goose/docs/guides/config-file
+		appData := os.Getenv("APPDATA")
+		if appData == "" {
+			return fmt.Errorf("APPDATA environment variable not set")
+		}
+		configPath = filepath.Join(appData, "Block", "goose", "config", "config.yaml")
+	} else {
+		// macOS/Linux: ~/.config/goose/config.yaml
+		configPath, err = homedir.Expand(filepath.Join("~", ".config", "goose", "config.yaml"))
+		if err != nil {
+			return err
+		}
 	}
 
 	// Create directory if it doesn't exist

cmd/container-use/agent/configure_ui.go

@@ -2,6 +2,7 @@ package agent
 
 import (
 	"fmt"
+	"runtime"
 	"strings"
 
 	tea "github.com/charmbracelet/bubbletea"
@@ -35,15 +36,30 @@ var agents = []Agent{
 	{
 		Key:         "codex",
 		Name:        "OpenAI Codex",
-		Description: "OpenAI's lightweight coding agent that runs in your terminal",
+		Description: "OpenAI's lightweight coding agent that runs in your terminal (Linux/macOS/WSL)",
 	},
 	{
 		Key:         "amazonq",
 		Name:        "Amazon Q Developer",
-		Description: "Amazon's agentic chat experience in your terminal",
+		Description: "Amazon's agentic chat experience in your terminal (Linux/macOS/WSL)",
 	},
 }
 
+// getSupportedAgents returns agents that are supported on the current platform
+func getSupportedAgents() []Agent {
+	if runtime.GOOS == "windows" {
+		// Filter out Windows-incompatible agents
+		var supportedAgents []Agent
+		for _, agent := range agents {
+			if agent.Key != "codex" && agent.Key != "amazonq" {
+				supportedAgents = append(supportedAgents, agent)
+			}
+		}
+		return supportedAgents
+	}
+	return agents
+}
+
 // AgentSelectorModel represents the bubbletea model for agent selection
 type AgentSelectorModel struct {
 	cursor   int
@@ -63,6 +79,7 @@ func (m AgentSelectorModel) Init() tea.Cmd {
 
 // Update handles incoming messages and updates the model
 func (m AgentSelectorModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	supportedAgents := getSupportedAgents()
 	switch msg := msg.(type) {
 	case tea.KeyMsg:
 		switch msg.String() {
@@ -74,11 +91,11 @@ func (m AgentSelectorModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 				m.cursor--
 			}
 		case "down", "j":
-			if m.cursor < len(agents)-1 {
+			if m.cursor < len(supportedAgents)-1 {
 				m.cursor++
 			}
 		case "enter", " ":
-			m.selected = agents[m.cursor].Key
+			m.selected = supportedAgents[m.cursor].Key
 			m.quit = true
 			return m, tea.Quit
 		}
@@ -137,8 +154,19 @@ func (m AgentSelectorModel) View() string {
 	s.WriteString(headerStyle.Render("Select an agent to configure:"))
 	s.WriteString("\n\n")
 
+	// Show WSL note for Windows users
+	if runtime.GOOS == "windows" {
+		wslNoteStyle := lipgloss.NewStyle().
+			Foreground(lipgloss.Color("#FFA500")).
+			Padding(0, 1).
+			Italic(true)
+		s.WriteString(wslNoteStyle.Render("Note: OpenAI Codex and Amazon Q Developer are available in WSL"))
+		s.WriteString("\n\n")
+	}
+
 	// Agent list TODO: filter or sort agents based on if they are installed (ConfigurableAgent.isInstalled())
-	for i, agent := range agents {
+	supportedAgents := getSupportedAgents()
+	for i, agent := range supportedAgents {
 		cursor := "  " // not selected
 		if m.cursor == i {
 			cursor = "▶ " // selected

cmd/container-use/completion_override.go

@@ -12,14 +12,14 @@ var commandName string
 func init() {
 	// Override cobra's default completion command
 	completionCmd := &cobra.Command{
-		Use:   "completion [bash|zsh|fish]",
+		Use:   "completion [bash|zsh|fish|powershell]",
 		Short: "Generate the autocompletion script for the specified shell",
 		Long: `Generate the autocompletion script for container-use for the specified shell.
 See each sub-command's help for details on how to use the generated script.
 
 Use --command-name to generate completions for a different command name (e.g., 'cu').`,
 		DisableFlagsInUseLine: true,
-		ValidArgs:             []string{"bash", "zsh", "fish"},
+		ValidArgs:             []string{"bash", "zsh", "fish", "powershell"},
 		Args:                  cobra.MatchAll(cobra.ExactArgs(1), cobra.OnlyValidArgs),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return generateCompletionForBinary(args[0])
@@ -29,7 +29,7 @@ Use --command-name to generate completions for a different command name (e.g., '
 	completionCmd.PersistentFlags().StringVar(&commandName, "command-name", "container-use", "Command name to use in completions")
 
 	// Add help subcommands that show usage instructions
-	for _, shell := range []string{"bash", "zsh", "fish"} {
+	for _, shell := range []string{"bash", "zsh", "fish", "powershell"} {
 		shell := shell // capture loop variable
 		helpCmd := &cobra.Command{
 			Use:   shell,
@@ -65,6 +65,8 @@ func generateCompletionForBinary(shell string) error {
 		return tempRootCmd.GenZshCompletion(os.Stdout)
 	case "fish":
 		return tempRootCmd.GenFishCompletion(os.Stdout, true)
+	case "powershell":
+		return tempRootCmd.GenPowerShellCompletion(os.Stdout)
 	}
 	return nil
 }
@@ -81,8 +83,14 @@ If it is not installed already, you can install it via your OS's package manager
 To load completions in your current shell session:
 	source <({{.command}} completion bash)
 
-To load completions for every new session, execute once:
-	{{.command}} completion bash > /usr/local/etc/bash_completion.d/{{.command}}`,
+To load completions for every new session, save the output to your bash completion directory.
+Common locations include:
+  - Linux: /usr/local/etc/bash_completion.d/{{.command}}
+  - macOS: $(brew --prefix)/etc/bash_completion.d/{{.command}}
+  - Windows (Git Bash): /usr/share/bash-completion/completions/{{.command}}
+
+Example:
+	{{.command}} completion bash > /path/to/bash_completion.d/{{.command}}`,
 
 		"zsh": `Generate the autocompletion script for the zsh shell.
 
@@ -93,16 +101,42 @@ you will need to enable it. You can execute the following once:
 To load completions in your current shell session:
 	source <({{.command}} completion zsh)
 
-To load completions for every new session, execute once:
-	{{.command}} completion zsh > /usr/local/share/zsh/site-functions/_{{.command}}`,
+To load completions for every new session, save the output to your zsh completion directory.
+Common locations include:
+  - Linux: /usr/local/share/zsh/site-functions/_{{.command}}
+  - macOS: $(brew --prefix)/share/zsh/site-functions/_{{.command}}
+  - Custom: Any directory in your $fpath
+
+Example:
+	{{.command}} completion zsh > /path/to/zsh/site-functions/_{{.command}}`,
 
 		"fish": `Generate the autocompletion script for the fish shell.
 
 To load completions in your current shell session:
 	{{.command}} completion fish | source
 
-To load completions for every new session, execute once:
+To load completions for every new session, save the output to your fish completion directory.
+Common locations include:
+  - Linux/macOS: ~/.config/fish/completions/{{.command}}.fish
+  - Windows: %APPDATA%\fish\completions\{{.command}}.fish
+
+Example:
 	{{.command}} completion fish > ~/.config/fish/completions/{{.command}}.fish`,
+
+		"powershell": `Generate the autocompletion script for PowerShell.
+
+To load completions in your current shell session:
+	{{.command}} completion powershell | Out-String | Invoke-Expression
+
+To load completions for every new session, add the output to your PowerShell profile.
+Common profile locations include:
+  - Windows: $PROFILE (usually %USERPROFILE%\Documents\PowerShell\Microsoft.PowerShell_profile.ps1)
+  - Linux/macOS: ~/.config/powershell/Microsoft.PowerShell_profile.ps1
+
+Example:
+	{{.command}} completion powershell >> $PROFILE
+
+Note: You may need to create the profile file if it doesn't exist.`,
 	}
 
 	template := templates[shell]

cmd/container-use/docker_errors.go

@@ -13,8 +13,24 @@ func isDockerDaemonError(err error) bool {
 	}
 
 	errStr := strings.ToLower(err.Error())
-	return strings.Contains(errStr, "cannot connect to the docker daemon") ||
-		strings.Contains(errStr, "docker daemon") ||
+
+	// Linux: Cannot connect to the Docker daemon at unix:///var/run/docker.sock. Is the docker daemon running?
+	if strings.Contains(errStr, "cannot connect to the docker daemon") {
+		return true
+	}
+
+	// Windows: error during connect: Get "http://%2F%2F.%2Fpipe%2FdockerDesktopLinuxEngine/v1.51/containers/json": open //./pipe/dockerDesktopLinuxEngine: The system cannot find the file specified.
+	if strings.Contains(errStr, "error during connect") && strings.Contains(errStr, "pipe/dockerdesktoplinuxengine") && strings.Contains(errStr, "the system cannot find the file specified") {
+		return true
+	}
+
+	// macOS: request returned 500 Internal Server Error for API route and version http://%2FUsers%2Fb1tank%2F.docker%2Frun%2Fdocker.sock/v1.50/containers/json, check if the server supports the requested API version
+	if strings.Contains(errStr, "request returned 500 internal server error") && strings.Contains(errStr, "docker.sock") && strings.Contains(errStr, "check if the server supports the requested api version") {
+		return true
+	}
+
+	// Generic fallbacks
+	return strings.Contains(errStr, "docker daemon") ||
 		strings.Contains(errStr, "docker.sock")
 }
 

cmd/container-use/docker_errors_test.go

@@ -17,10 +17,30 @@ func TestIsDockerDaemonError(t *testing.T) {
 			expected: false,
 		},
 		{
-			name:     "docker daemon error",
+			name:     "docker daemon error - linux",
 			err:      errors.New("Cannot connect to the Docker daemon at unix:///var/run/docker.sock. Is the docker daemon running?"),
 			expected: true,
 		},
+		{
+			name:     "docker daemon error - windows",
+			err:      errors.New("error during connect: Get \"http://%2F%2F.%2Fpipe%2FdockerDesktopLinuxEngine/v1.51/containers/json\": open //./pipe/dockerDesktopLinuxEngine: The system cannot find the file specified."),
+			expected: true,
+		},
+		{
+			name:     "docker daemon error - macos",
+			err:      errors.New("request returned 500 Internal Server Error for API route and version http://%2FUsers%2Fb1tank%2F.docker%2Frun%2Fdocker.sock/v1.50/containers/json, check if the server supports the requested API version"),
+			expected: true,
+		},
+		{
+			name:     "docker daemon error - generic",
+			err:      errors.New("docker daemon is not running"),
+			expected: true,
+		},
+		{
+			name:     "docker socket error - generic",
+			err:      errors.New("connection to docker.sock failed"),
+			expected: true,
+		},
 		{
 			name:     "other error",
 			err:      errors.New("some other error"),

cmd/container-use/logger.go

@@ -5,6 +5,7 @@ import (
 	"io"
 	"log/slog"
 	"os"
+	"path/filepath"
 	"time"
 )
 
@@ -30,7 +31,7 @@ func parseLogLevel(levelStr string) slog.Level {
 func setupLogger() error {
 	var writers []io.Writer
 
-	logFile := "/tmp/container-use.debug.stderr.log"
+	logFile := filepath.Join(os.TempDir(), "container-use.debug.stderr.log")
 	if v, ok := os.LookupEnv("CONTAINER_USE_STDERR_FILE"); ok {
 		logFile = v
 	}

cmd/container-use/main.go

@@ -4,11 +4,7 @@ import (
 	"context"
 	_ "embed"
 	"fmt"
-	"io"
 	"os"
-	"os/signal"
-	"runtime"
-	"syscall"
 
 	"github.com/charmbracelet/fang"
 	"github.com/dagger/container-use/repository"
@@ -26,9 +22,7 @@ Each environment runs in its own container with dedicated git branches.`,
 
 func main() {
 	ctx := context.Background()
-	sigusrCh := make(chan os.Signal, 1)
-	signal.Notify(sigusrCh, syscall.SIGUSR1)
-	go handleSIGUSR(sigusrCh)
+	setupSignalHandling()
 
 	if err := setupLogger(); err != nil {
 		fmt.Fprintf(os.Stderr, "Failed to setup logger: %v\n", err)
@@ -50,26 +44,12 @@ func main() {
 		rootCmd,
 		fang.WithVersion(version),
 		fang.WithCommit(commit),
-		fang.WithNotifySignal(os.Interrupt, os.Kill, syscall.SIGTERM),
+		fang.WithNotifySignal(getNotifySignals()...),
 	); err != nil {
 		os.Exit(1)
 	}
 }
 
-func handleSIGUSR(sigusrCh <-chan os.Signal) {
-	for sig := range sigusrCh {
-		if sig == syscall.SIGUSR1 {
-			dumpStacks()
-		}
-	}
-}
-
-func dumpStacks() {
-	buf := make([]byte, 1<<20) // 1MB buffer
-	n := runtime.Stack(buf, true)
-	io.MultiWriter(logWriter, os.Stderr).Write(buf[:n])
-}
-
 func suggestEnvironments(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
 	ctx := cmd.Context()