fix windows build & run

cmd/daemon.go

@@ -0,0 +1,37 @@
+package root
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+)
+
+func prepareDaemonCommand() (*exec.Cmd, error) {
+	// Get the current executable path
+	executable, err := os.Executable()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get executable path: %w", err)
+	}
+
+	// Get current working directory
+	workDir, err := os.Getwd()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get working directory: %w", err)
+	}
+
+	// Build command arguments, excluding the daemon flag
+	args := os.Args[1:]
+	var newArgs []string
+	for _, arg := range args {
+		if arg != "--daemon" {
+			newArgs = append(newArgs, arg)
+		}
+	}
+
+	// Create the command
+	cmd := exec.Command(executable, newArgs...)
+	cmd.Dir = workDir
+	cmd.Env = os.Environ()
+
+	return cmd, nil
+}

cmd/daemon_unix.go

@@ -0,0 +1,33 @@
+//go:build !windows
+
+package root
+
+import (
+	"fmt"
+	"os"
+	"syscall"
+)
+
+// daemonize forks the process to run in the background
+func daemonize() error {
+	cmd, err := prepareDaemonCommand()
+	if err != nil {
+		return err
+	}
+
+	// Set up process attributes for daemon behavior
+	cmd.SysProcAttr = &syscall.SysProcAttr{
+		Setsid: true, // Create new session
+	}
+
+	// Start the process
+	if err := cmd.Start(); err != nil {
+		return fmt.Errorf("failed to start daemon process: %w", err)
+	}
+
+	// Exit the parent process
+	os.Exit(0)
+
+	// This line should never be reached, but Go requires it
+	return nil
+}

cmd/daemon_windows.go

@@ -0,0 +1,32 @@
+//go:build windows
+
+package root
+
+import (
+	"fmt"
+	"os"
+	"syscall"
+)
+
+// daemonize forks the process to run in the background
+func daemonize() error {
+	cmd, err := prepareDaemonCommand()
+	if err != nil {
+		return err
+	}
+
+	// On Windows, use DETACHED_PROCESS flag to run in the background
+	// without being attached to the parent's console.
+	cmd.SysProcAttr = &syscall.SysProcAttr{CreationFlags: syscall.DETACHED_PROCESS}
+
+	// Start the process
+	if err := cmd.Start(); err != nil {
+		return fmt.Errorf("failed to start daemon process: %w", err)
+	}
+
+	// Exit the parent process
+	os.Exit(0)
+
+	// This line should never be reached, but Go requires it
+	return nil
+}

cmd/mcp.go

@@ -3,7 +3,6 @@ package root
 import (
 	"fmt"
 	"os"
-	"os/exec"
 	"os/signal"
 	"syscall"
 
@@ -111,57 +110,6 @@ and ignore SIGHUP signals.
 	},
 }
 
-// daemonize forks the process to run in the background
-func daemonize() error {
-	// Get the current executable path
-	executable, err := os.Executable()
-	if err != nil {
-		return fmt.Errorf("failed to get executable path: %w", err)
-	}
-
-	// Get current working directory
-	workDir, err := os.Getwd()
-	if err != nil {
-		return fmt.Errorf("failed to get working directory: %w", err)
-	}
-
-	// Build command arguments, excluding the daemon flag
-	args := os.Args[1:]
-	var newArgs []string
-	for i, arg := range args {
-		if arg == "--daemon" {
-			// Skip the daemon flag
-			continue
-		}
-		if i > 0 && args[i-1] == "--daemon" {
-			// Skip the value if it was a separate argument
-			continue
-		}
-		newArgs = append(newArgs, arg)
-	}
-
-	// Create the command
-	cmd := exec.Command(executable, newArgs...)
-	cmd.Dir = workDir
-	cmd.Env = os.Environ()
-
-	// Set up process attributes for daemon behavior
-	cmd.SysProcAttr = &syscall.SysProcAttr{
-		Setsid: true, // Create new session
-	}
-
-	// Start the process
-	if err := cmd.Start(); err != nil {
-		return fmt.Errorf("failed to start daemon process: %w", err)
-	}
-
-	// Exit the parent process
-	os.Exit(0)
-
-	// This line should never be reached, but Go requires it
-	return nil
-}
-
 // setupSIGHUPHandler sets up signal handling to ignore SIGHUP in daemon mode
 func setupSIGHUPHandler(logger *common.Logger) {
 	sigChan := make(chan os.Signal, 1)

pkg/command/command_exec.go

@@ -85,7 +85,7 @@ func (h *CommandHandler) executeToolCommand(ctx context.Context, params map[stri
 	}
 
 	// Wrap command with timeout if configured and timeout command is available
-	if h.timeout != "" && common.CheckExecutableExists("timeout") {
+	if h.timeout != "" {
 		timeoutDuration, err := time.ParseDuration(h.timeout)
 		if err != nil {
 			h.logger.Error("Invalid timeout format '%s': %v", h.timeout, err)
@@ -101,15 +101,17 @@ func (h *CommandHandler) executeToolCommand(ctx context.Context, params map[stri
 		// Escape single quotes in the command for shell
 		escapedCmd := strings.ReplaceAll(cmd, "'", "'\"'\"'")
 
-		// Wrap the command with timeout
-		// Using timeout command which will kill the entire process group
-		// This works reliably on Unix/Linux/macOS systems
-		cmd = fmt.Sprintf("timeout --kill-after=5s %ds sh -c '%s'", timeoutSeconds, escapedCmd)
-		h.logger.Debug("Wrapped command with Unix timeout: %ds", timeoutSeconds)
-	} else if h.timeout != "" {
-		// timeout command not available (probably Windows)
-		// Fall back to context-based timeout (less reliable for child processes)
-		h.logger.Debug("Unix timeout command not available, using context-based timeout: %s", h.timeout)
+		// On Unix systems, try to use the 'timeout' command if available, otherwise use context-based timeout
+		// On Windows, always use context-based timeout as 'timeout' command doesn't limit execution time
+		if shouldUseUnixTimeoutCommand() {
+			// On Unix/Linux/macOS systems, use timeout command with Unix syntax
+			cmd = fmt.Sprintf("timeout --kill-after=5s %ds sh -c '%s'", timeoutSeconds, escapedCmd)
+			h.logger.Debug("Wrapped command with Unix timeout: %ds", timeoutSeconds)
+		} else {
+			// timeout command not available on this platform or this is Windows
+			// Fall back to context-based timeout (less reliable for child processes)
+			h.logger.Debug("Timeout command not available, using context-based timeout: %s", h.timeout)
+		}
 	}
 
 	// h.logger.Debug("Processed command: %s", cmd)

pkg/command/platform_unix.go

@@ -0,0 +1,29 @@
+//go:build !windows
+
+package command
+
+import (
+	"strings"
+
+	"github.com/inercia/MCPShell/pkg/common"
+)
+
+// getShellCommandArgs returns the correct arguments for different shell types on Unix systems
+func getShellCommandArgs(shell string, command string) (string, []string) {
+	shellLower := strings.ToLower(shell)
+
+	// Check if this is a PowerShell (might be available on Unix via PowerShell Core)
+	if strings.Contains(shellLower, "powershell") ||
+		strings.HasSuffix(shellLower, "powershell.exe") ||
+		strings.HasSuffix(shellLower, "pwsh.exe") {
+		return shell, []string{"-Command", command}
+	}
+
+	// For Unix-like systems and default fallback
+	return shell, []string{"-c", command}
+}
+
+// shouldUseUnixTimeoutCommand returns whether to use the Unix-style timeout command
+func shouldUseUnixTimeoutCommand() bool {
+	return common.CheckExecutableExists("timeout")
+}

pkg/command/platform_windows.go

@@ -0,0 +1,38 @@
+//go:build windows
+
+package command
+
+import (
+	"runtime"
+	"strings"
+)
+
+// getShellCommandArgs returns the correct arguments for different shell types on Windows
+func getShellCommandArgs(shell string, command string) (string, []string) {
+	shellLower := strings.ToLower(shell)
+
+	// Check if this is a cmd shell (Windows)
+	if strings.Contains(shellLower, "cmd") ||
+		strings.HasSuffix(shellLower, "cmd.exe") ||
+		(shell == "" && runtime.GOOS == "windows") { // Default to cmd on Windows if no shell specified
+		return shell, []string{"/c", command}
+	}
+
+	// Check if this is a PowerShell
+	if strings.Contains(shellLower, "powershell") ||
+		strings.HasSuffix(shellLower, "powershell.exe") ||
+		strings.HasSuffix(shellLower, "pwsh.exe") {
+		return shell, []string{"-Command", command}
+	}
+
+	// For WSL, we might have bash or other Unix shells
+	// For Unix-like systems and default fallback
+	return shell, []string{"-c", command}
+}
+
+// shouldUseUnixTimeoutCommand returns whether to use the Unix-style timeout command
+func shouldUseUnixTimeoutCommand() bool {
+	// On Windows, we don't use Unix-style timeout command even if a 'timeout' command exists
+	// because Windows 'timeout' is for pausing, not for limiting execution time
+	return false
+}