fix proto escaping

cli/pkg/cli/global/cline-clients.go

@@ -3,15 +3,9 @@ package global
 import (
 	"context"
 	"fmt"
-	"os"
-	"os/exec"
-	"path"
-	"path/filepath"
-	"syscall"
 	"time"
 
 	"github.com/cline/cli/pkg/common"
-	"github.com/cline/grpc-go/cline"
 )
 
 // ClineClients manages Cline instances using the new registry system
@@ -242,269 +236,3 @@ func (c *ClineClients) EnsureInstanceAtAddress(ctx context.Context, address stri
 	return fmt.Errorf("cannot start remote instance at %s", normalized)
 }
 
-func startClineHost(hostPort int, workspaces []string) (*exec.Cmd, error) {
-	if Config.Verbose {
-		fmt.Printf("Starting cline-host on port %d\n", hostPort)
-	}
-
-	// Get the directory where the cline binary is located
-	execPath, err := os.Executable()
-	if err != nil {
-		return nil, fmt.Errorf("failed to get executable path: %w", err)
-	}
-	binDir := path.Dir(execPath)
-	clineHostPath := path.Join(binDir, "cline-host")
-
-	// Build command arguments
-	args := []string{
-		"--verbose",
-		"--port", fmt.Sprintf("%d", hostPort),
-	}
-
-	for _, ws := range workspaces {
-		args = append(args, "--workspace", ws)
-	}
-
-	// Start the cline-host process
-	cmd := exec.Command(clineHostPath, args...)
-
-	// Create logs directory in ~/.cline/logs
-	logsDir := path.Join(Config.ConfigPath, "logs")
-	if err := os.MkdirAll(logsDir, 0755); err != nil {
-		return nil, fmt.Errorf("failed to create logs directory: %w", err)
-	}
-
-	// Create timestamped log file
-	timestamp := time.Now().Format("2006-01-02-15-04-05")
-	logFileName := fmt.Sprintf("cline-host-%s-localhost-%d.log", timestamp, hostPort)
-	logFilePath := path.Join(logsDir, logFileName)
-	logFile, err := os.Create(logFilePath)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create log file: %w", err)
-	}
-
-	// Redirect stdout and stderr to log file
-	cmd.Stdout = logFile
-	cmd.Stderr = logFile
-
-	// Put the child process in a new process group so Ctrl+C doesn't kill it
-	cmd.SysProcAttr = &syscall.SysProcAttr{
-		Setpgid: true,
-	}
-
-	if err := cmd.Start(); err != nil {
-		logFile.Close()
-		return nil, fmt.Errorf("failed to start cline-host: %w", err)
-	}
-
-	if Config.Verbose {
-		fmt.Printf("Started cline-host (PID: %d)\n", cmd.Process.Pid)
-		fmt.Printf("Logging cline-host output to: %s\n", logFilePath)
-	}
-	return cmd, nil
-}
-
-// KillInstanceByAddress kills a Cline instance by its address
-func KillInstanceByAddress(ctx context.Context, registry *ClientRegistry, address string) error {
-	// Check if the instance exists in the registry
-	_, err := registry.GetInstance(address)
-	if err != nil {
-		return fmt.Errorf("instance %s not found in registry", address)
-	}
-
-	if Config.Verbose {
-		fmt.Printf("Killing instance: %s\n", address)
-	}
-
-	// Get gRPC client and process info
-	client, err := registry.GetClient(ctx, address)
-	if err != nil {
-		return fmt.Errorf("failed to connect to instance %s: %w", address, err)
-	}
-
-	processInfo, err := client.State.GetProcessInfo(ctx, &cline.EmptyRequest{})
-	if err != nil {
-		return fmt.Errorf("failed to get process info for instance %s: %w", address, err)
-	}
-
-	pid := int(processInfo.ProcessId)
-	if Config.Verbose {
-		fmt.Printf("Terminating process PID %d...\n", pid)
-	}
-
-	// Kill the process
-	if err := syscall.Kill(pid, syscall.SIGTERM); err != nil {
-		return fmt.Errorf("failed to kill process %d: %w", pid, err)
-	}
-
-	// Wait for the instance to remove itself from registry
-	if Config.Verbose {
-		fmt.Printf("Waiting for instance to clean up registry entry...\n")
-	}
-	for range 5 {
-		time.Sleep(1 * time.Second)
-		if !registry.HasInstanceAtAddress(address) {
-			if Config.Verbose {
-				fmt.Printf("Instance %s successfully killed and removed from registry.\n", address)
-			}
-
-			// Update default instance if needed
-			instances, err := registry.ListInstancesCleaned(ctx)
-			if err == nil && len(instances) > 0 {
-				// ensureDefaultInstance logic will handle setting a new default
-				defaultInstance := registry.GetDefaultInstance()
-				if defaultInstance == address || defaultInstance == "" {
-					if len(instances) > 0 {
-						if err := registry.SetDefaultInstance(instances[0].Address); err == nil {
-							if Config.Verbose {
-								fmt.Printf("Updated default instance to: %s\n", instances[0].Address)
-							}
-						}
-					}
-				}
-			}
-
-			return nil
-		}
-	}
-
-	return fmt.Errorf("instance killed but failed to remove itself from registry within 5 seconds")
-}
-
-func startClineCore(corePort, hostPort int) (*exec.Cmd, error) {
-	if Config.Verbose {
-		fmt.Printf("Starting cline-core on port %d (with hostbridge on %d)\n", corePort, hostPort)
-	}
-
-	// Get the executable path and resolve symlinks (for npm global installs)
-	execPath, err := os.Executable()
-	if err != nil {
-		return nil, fmt.Errorf("failed to get executable path: %w", err)
-	}
-
-	// Resolve symlinks to get the real path
-	// For npm global installs, execPath might be a symlink like:
-	// /opt/homebrew/bin/cline -> /opt/homebrew/lib/node_modules/cline/bin/cline
-	realPath, err := filepath.EvalSymlinks(execPath)
-	if err != nil {
-		// If we can't resolve symlinks, fall back to the original path
-		realPath = execPath
-		if Config.Verbose {
-			fmt.Printf("Warning: Could not resolve symlinks for %s: %v\n", execPath, err)
-		}
-	}
-
-	binDir := path.Dir(realPath)
-	installDir := path.Dir(binDir)
-	clineCorePath := path.Join(installDir, "cline-core.js")
-
-	if Config.Verbose {
-		fmt.Printf("Executable path: %s\n", execPath)
-		if realPath != execPath {
-			fmt.Printf("Real path (after resolving symlinks): %s\n", realPath)
-		}
-		fmt.Printf("Bin directory: %s\n", binDir)
-		fmt.Printf("Install directory: %s\n", installDir)
-		fmt.Printf("Looking for cline-core.js at: %s\n", clineCorePath)
-	}
-
-	// Check if cline-core.js exists at the primary location
-	var finalClineCorePath string
-	var finalInstallDir string
-	if _, err := os.Stat(clineCorePath); os.IsNotExist(err) {
-		// Development mode: Try ../../dist-standalone/cline-core.js
-		// This handles the case where we're running from cli/bin/cline
-		devClineCorePath := path.Join(binDir, "..", "..", "dist-standalone", "cline-core.js")
-		devInstallDir := path.Join(binDir, "..", "..", "dist-standalone")
-
-		if Config.Verbose {
-			fmt.Printf("Primary location not found, trying development path: %s\n", devClineCorePath)
-		}
-
-		if _, err := os.Stat(devClineCorePath); os.IsNotExist(err) {
-			return nil, fmt.Errorf("cline-core.js not found at '%s' or '%s'. Please ensure you're running from the correct location or reinstall with 'npm install -g cline'", clineCorePath, devClineCorePath)
-		}
-
-		finalClineCorePath = devClineCorePath
-		finalInstallDir = devInstallDir
-		if Config.Verbose {
-			fmt.Printf("Using development mode: cline-core.js found at %s\n", finalClineCorePath)
-		}
-	} else {
-		finalClineCorePath = clineCorePath
-		finalInstallDir = installDir
-		if Config.Verbose {
-			fmt.Printf("Using production mode: cline-core.js found at %s\n", finalClineCorePath)
-		}
-	}
-
-	// Create logs directory in ~/.cline/logs
-	logsDir := path.Join(Config.ConfigPath, "logs")
-	if err := os.MkdirAll(logsDir, 0755); err != nil {
-		return nil, fmt.Errorf("failed to create logs directory: %w", err)
-	}
-
-	// Create timestamped log file
-	timestamp := time.Now().Format("2006-01-02-15-04-05")
-	logFileName := fmt.Sprintf("cline-core-%s-localhost-%d.log", timestamp, corePort)
-	logFilePath := path.Join(logsDir, logFileName)
-	logFile, err := os.Create(logFilePath)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create log file: %w", err)
-	}
-
-	// Start the cline-core process with --config flag using system node
-	args := []string{finalClineCorePath,
-		"--port", fmt.Sprintf("%d", corePort),
-		"--host-bridge-port", fmt.Sprintf("%d", hostPort),
-		"--config", Config.ConfigPath}
-
-	if Config.Verbose {
-		fmt.Printf("Using system node\n")
-	}
-
-	cmd := exec.Command("node", args...)
-
-	// Set working directory to installation root
-	cmd.Dir = finalInstallDir
-
-	// Redirect stdout and stderr to log file
-	cmd.Stdout = logFile
-	cmd.Stderr = logFile
-
-	// Put the child process in a new process group so Ctrl+C doesn't kill it
-	cmd.SysProcAttr = &syscall.SysProcAttr{
-		Setpgid: true,
-	}
-
-	// Set environment variables with NODE_PATH for both real and fake node_modules
-	// The fake node_modules contains the vscode stub that can't be in the real node_modules
-	env := os.Environ()
-	realNodeModules := path.Join(finalInstallDir, "node_modules")
-	fakeNodeModules := path.Join(finalInstallDir, "fake_node_modules")
-	nodePath := fmt.Sprintf("%s%c%s", realNodeModules, os.PathListSeparator, fakeNodeModules)
-
-	env = append(env,
-		fmt.Sprintf("NODE_PATH=%s", nodePath),
-		// These control gRPC debug logging
-		//"GRPC_TRACE=all",
-		//"GRPC_VERBOSITY=DEBUG",
-		"NODE_ENV=development",
-	)
-	cmd.Env = env
-
-	if Config.Verbose {
-		fmt.Printf("NODE_PATH set to: %s\n", nodePath)
-	}
-
-	if err := cmd.Start(); err != nil {
-		logFile.Close()
-		return nil, fmt.Errorf("failed to start cline-core: %w", err)
-	}
-
-	if Config.Verbose {
-		fmt.Printf("Started cline-core (PID: %d)\n", cmd.Process.Pid)
-		fmt.Printf("Logging cline-core output to: %s\n", logFilePath)
-	}
-	return cmd, nil
-}

cli/pkg/cli/global/run-unix.go

@@ -0,0 +1,282 @@
+//go:build !windows
+
+package global
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"syscall"
+	"time"
+
+	"github.com/cline/grpc-go/cline"
+)
+
+func startClineHost(hostPort int, workspaces []string) (*exec.Cmd, error) {
+	if Config.Verbose {
+		fmt.Printf("Starting cline-host on port %d\n", hostPort)
+	}
+
+	// Get the directory where the cline binary is located
+	execPath, err := os.Executable()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get executable path: %w", err)
+	}
+	binDir := filepath.Dir(execPath)
+	clineHostPath := filepath.Join(binDir, "cline-host")
+
+	// Build command arguments
+	args := []string{
+		"--verbose",
+		"--port", fmt.Sprintf("%d", hostPort),
+	}
+
+	for _, ws := range workspaces {
+		args = append(args, "--workspace", ws)
+	}
+
+	// Start the cline-host process
+	cmd := exec.Command(clineHostPath, args...)
+
+	// Create logs directory in ~/.cline/logs
+	logsDir := filepath.Join(Config.ConfigPath, "logs")
+	if err := os.MkdirAll(logsDir, 0755); err != nil {
+		return nil, fmt.Errorf("failed to create logs directory: %w", err)
+	}
+
+	// Create timestamped log file
+	timestamp := time.Now().Format("2006-01-02-15-04-05")
+	logFileName := fmt.Sprintf("cline-host-%s-localhost-%d.log", timestamp, hostPort)
+	logFilePath := filepath.Join(logsDir, logFileName)
+	logFile, err := os.Create(logFilePath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create log file: %w", err)
+	}
+
+	// Redirect stdout and stderr to log file
+	cmd.Stdout = logFile
+	cmd.Stderr = logFile
+
+	// Put the child process in a new process group so Ctrl+C doesn't kill it
+	cmd.SysProcAttr = &syscall.SysProcAttr{
+		Setpgid: true,
+	}
+
+	if err := cmd.Start(); err != nil {
+		logFile.Close()
+		return nil, fmt.Errorf("failed to start cline-host: %w", err)
+	}
+
+	if Config.Verbose {
+		fmt.Printf("Started cline-host (PID: %d)\n", cmd.Process.Pid)
+		fmt.Printf("Logging cline-host output to: %s\n", logFilePath)
+	}
+	return cmd, nil
+}
+
+// KillInstanceByAddress kills a Cline instance by its address
+func KillInstanceByAddress(ctx context.Context, registry *ClientRegistry, address string) error {
+	// Check if the instance exists in the registry
+	_, err := registry.GetInstance(address)
+	if err != nil {
+		return fmt.Errorf("instance %s not found in registry", address)
+	}
+
+	if Config.Verbose {
+		fmt.Printf("Killing instance: %s\n", address)
+	}
+
+	// Get gRPC client and process info
+	client, err := registry.GetClient(ctx, address)
+	if err != nil {
+		return fmt.Errorf("failed to connect to instance %s: %w", address, err)
+	}
+
+	processInfo, err := client.State.GetProcessInfo(ctx, &cline.EmptyRequest{})
+	if err != nil {
+		return fmt.Errorf("failed to get process info for instance %s: %w", address, err)
+	}
+
+	pid := int(processInfo.ProcessId)
+	if Config.Verbose {
+		fmt.Printf("Terminating process PID %d...\n", pid)
+	}
+
+	// Kill the process
+	if err := syscall.Kill(pid, syscall.SIGTERM); err != nil {
+		return fmt.Errorf("failed to kill process %d: %w", pid, err)
+	}
+
+	// Wait for the instance to remove itself from registry
+	if Config.Verbose {
+		fmt.Printf("Waiting for instance to clean up registry entry...\n")
+	}
+	for range 5 {
+		time.Sleep(1 * time.Second)
+		if !registry.HasInstanceAtAddress(address) {
+			if Config.Verbose {
+				fmt.Printf("Instance %s successfully killed and removed from registry.\n", address)
+			}
+
+			// Update default instance if needed
+			instances, err := registry.ListInstancesCleaned(ctx)
+			if err == nil && len(instances) > 0 {
+				// ensureDefaultInstance logic will handle setting a new default
+				defaultInstance := registry.GetDefaultInstance()
+				if defaultInstance == address || defaultInstance == "" {
+					if len(instances) > 0 {
+						if err := registry.SetDefaultInstance(instances[0].Address); err == nil {
+							if Config.Verbose {
+								fmt.Printf("Updated default instance to: %s\n", instances[0].Address)
+							}
+						}
+					}
+				}
+			}
+
+			return nil
+		}
+	}
+
+	return fmt.Errorf("instance killed but failed to remove itself from registry within 5 seconds")
+}
+
+func startClineCore(corePort, hostPort int) (*exec.Cmd, error) {
+	if Config.Verbose {
+		fmt.Printf("Starting cline-core on port %d (with hostbridge on %d)\n", corePort, hostPort)
+	}
+
+	// Get the executable path and resolve symlinks (for npm global installs)
+	execPath, err := os.Executable()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get executable path: %w", err)
+	}
+
+	// Resolve symlinks to get the real path
+	// For npm global installs, execPath might be a symlink like:
+	// /opt/homebrew/bin/cline -> /opt/homebrew/lib/node_modules/cline/bin/cline
+	realPath, err := filepath.EvalSymlinks(execPath)
+	if err != nil {
+		// If we can't resolve symlinks, fall back to the original path
+		realPath = execPath
+		if Config.Verbose {
+			fmt.Printf("Warning: Could not resolve symlinks for %s: %v\n", execPath, err)
+		}
+	}
+
+	binDir := filepath.Dir(realPath)
+	installDir := filepath.Dir(binDir)
+	clineCorePath := filepath.Join(installDir, "cline-core.js")
+
+	if Config.Verbose {
+		fmt.Printf("Executable path: %s\n", execPath)
+		if realPath != execPath {
+			fmt.Printf("Real path (after resolving symlinks): %s\n", realPath)
+		}
+		fmt.Printf("Bin directory: %s\n", binDir)
+		fmt.Printf("Install directory: %s\n", installDir)
+		fmt.Printf("Looking for cline-core.js at: %s\n", clineCorePath)
+	}
+
+	// Check if cline-core.js exists at the primary location
+	var finalClineCorePath string
+	var finalInstallDir string
+	if _, err := os.Stat(clineCorePath); os.IsNotExist(err) {
+		// Development mode: Try ../../dist-standalone/cline-core.js
+		// This handles the case where we're running from cli/bin/cline
+		devClineCorePath := filepath.Join(binDir, "..", "..", "dist-standalone", "cline-core.js")
+		devInstallDir := filepath.Join(binDir, "..", "..", "dist-standalone")
+
+		if Config.Verbose {
+			fmt.Printf("Primary location not found, trying development path: %s\n", devClineCorePath)
+		}
+
+		if _, err := os.Stat(devClineCorePath); os.IsNotExist(err) {
+			return nil, fmt.Errorf("cline-core.js not found at '%s' or '%s'. Please ensure you're running from the correct location or reinstall with 'npm install -g cline'", clineCorePath, devClineCorePath)
+		}
+
+		finalClineCorePath = devClineCorePath
+		finalInstallDir = devInstallDir
+		if Config.Verbose {
+			fmt.Printf("Using development mode: cline-core.js found at %s\n", finalClineCorePath)
+		}
+	} else {
+		finalClineCorePath = clineCorePath
+		finalInstallDir = installDir
+		if Config.Verbose {
+			fmt.Printf("Using production mode: cline-core.js found at %s\n", finalClineCorePath)
+		}
+	}
+
+	// Create logs directory in ~/.cline/logs
+	logsDir := filepath.Join(Config.ConfigPath, "logs")
+	if err := os.MkdirAll(logsDir, 0755); err != nil {
+		return nil, fmt.Errorf("failed to create logs directory: %w", err)
+	}
+
+	// Create timestamped log file
+	timestamp := time.Now().Format("2006-01-02-15-04-05")
+	logFileName := fmt.Sprintf("cline-core-%s-localhost-%d.log", timestamp, corePort)
+	logFilePath := filepath.Join(logsDir, logFileName)
+	logFile, err := os.Create(logFilePath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create log file: %w", err)
+	}
+
+	// Start the cline-core process with --config flag using system node
+	args := []string{finalClineCorePath,
+		"--port", fmt.Sprintf("%d", corePort),
+		"--host-bridge-port", fmt.Sprintf("%d", hostPort),
+		"--config", Config.ConfigPath}
+
+	if Config.Verbose {
+		fmt.Printf("Using system node\n")
+	}
+
+	cmd := exec.Command("node", args...)
+
+	// Set working directory to installation root
+	cmd.Dir = finalInstallDir
+
+	// Redirect stdout and stderr to log file
+	cmd.Stdout = logFile
+	cmd.Stderr = logFile
+
+	// Put the child process in a new process group so Ctrl+C doesn't kill it
+	cmd.SysProcAttr = &syscall.SysProcAttr{
+		Setpgid: true,
+	}
+
+	// Set environment variables with NODE_PATH for both real and fake node_modules
+	// The fake node_modules contains the vscode stub that can't be in the real node_modules
+	env := os.Environ()
+	realNodeModules := filepath.Join(finalInstallDir, "node_modules")
+	fakeNodeModules := filepath.Join(finalInstallDir, "fake_node_modules")
+	nodePath := fmt.Sprintf("%s%c%s", realNodeModules, os.PathListSeparator, fakeNodeModules)
+
+	env = append(env,
+		fmt.Sprintf("NODE_PATH=%s", nodePath),
+		// These control gRPC debug logging
+		//"GRPC_TRACE=all",
+		//"GRPC_VERBOSITY=DEBUG",
+		"NODE_ENV=development",
+	)
+	cmd.Env = env
+
+	if Config.Verbose {
+		fmt.Printf("NODE_PATH set to: %s\n", nodePath)
+	}
+
+	if err := cmd.Start(); err != nil {
+		logFile.Close()
+		return nil, fmt.Errorf("failed to start cline-core: %w", err)
+	}
+
+	if Config.Verbose {
+		fmt.Printf("Started cline-core (PID: %d)\n", cmd.Process.Pid)
+		fmt.Printf("Logging cline-core output to: %s\n", logFilePath)
+	}
+	return cmd, nil
+}

cli/pkg/cli/global/run-w32.go

@@ -0,0 +1,282 @@
+//go:build windows
+
+package global
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"syscall"
+	"time"
+
+	"github.com/cline/grpc-go/cline"
+)
+
+func startClineHost(hostPort int, workspaces []string) (*exec.Cmd, error) {
+	if Config.Verbose {
+		fmt.Printf("Starting cline-host on port %d\n", hostPort)
+	}
+
+	// Get the directory where the cline binary is located
+	execPath, err := os.Executable()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get executable path: %w", err)
+	}
+	binDir := filepath.Dir(execPath)
+	clineHostPath := filepath.Join(binDir, "cline-host")
+
+	// Build command arguments
+	args := []string{
+		"--verbose",
+		"--port", fmt.Sprintf("%d", hostPort),
+	}
+
+	for _, ws := range workspaces {
+		args = append(args, "--workspace", ws)
+	}
+
+	// Start the cline-host process
+	cmd := exec.Command(clineHostPath, args...)
+
+	// Create logs directory in ~/.cline/logs
+	logsDir := filepath.Join(Config.ConfigPath, "logs")
+	if err := os.MkdirAll(logsDir, 0755); err != nil {
+		return nil, fmt.Errorf("failed to create logs directory: %w", err)
+	}
+
+	// Create timestamped log file
+	timestamp := time.Now().Format("2006-01-02-15-04-05")
+	logFileName := fmt.Sprintf("cline-host-%s-localhost-%d.log", timestamp, hostPort)
+	logFilePath := filepath.Join(logsDir, logFileName)
+	logFile, err := os.Create(logFilePath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create log file: %w", err)
+	}
+
+	// Redirect stdout and stderr to log file
+	cmd.Stdout = logFile
+	cmd.Stderr = logFile
+
+	// Put the child process in a new process group so Ctrl+C doesn't kill it
+	cmd.SysProcAttr = &syscall.SysProcAttr{
+	CreationFlags: syscall.CREATE_NEW_PROCESS_GROUP,
+	}
+
+	if err := cmd.Start(); err != nil {
+		logFile.Close()
+		return nil, fmt.Errorf("failed to start cline-host: %w", err)
+	}
+
+	if Config.Verbose {
+		fmt.Printf("Started cline-host (PID: %d)\n", cmd.Process.Pid)
+		fmt.Printf("Logging cline-host output to: %s\n", logFilePath)
+	}
+	return cmd, nil
+}
+
+// KillInstanceByAddress kills a Cline instance by its address
+func KillInstanceByAddress(ctx context.Context, registry *ClientRegistry, address string) error {
+	// Check if the instance exists in the registry
+	_, err := registry.GetInstance(address)
+	if err != nil {
+		return fmt.Errorf("instance %s not found in registry", address)
+	}
+
+	if Config.Verbose {
+		fmt.Printf("Killing instance: %s\n", address)
+	}
+
+	// Get gRPC client and process info
+	client, err := registry.GetClient(ctx, address)
+	if err != nil {
+		return fmt.Errorf("failed to connect to instance %s: %w", address, err)
+	}
+
+	processInfo, err := client.State.GetProcessInfo(ctx, &cline.EmptyRequest{})
+	if err != nil {
+		return fmt.Errorf("failed to get process info for instance %s: %w", address, err)
+	}
+
+	pid := int(processInfo.ProcessId)
+	if Config.Verbose {
+		fmt.Printf("Terminating process PID %d...\n", pid)
+	}
+
+	// Kill the process
+	if err := syscall.TerminateProcess(syscall.Handle(pid), 15); err != nil {
+		return fmt.Errorf("failed to kill process %d: %w", pid, err)
+	}
+
+	// Wait for the instance to remove itself from registry
+	if Config.Verbose {
+		fmt.Printf("Waiting for instance to clean up registry entry...\n")
+	}
+	for range 5 {
+		time.Sleep(1 * time.Second)
+		if !registry.HasInstanceAtAddress(address) {
+			if Config.Verbose {
+				fmt.Printf("Instance %s successfully killed and removed from registry.\n", address)
+			}
+
+			// Update default instance if needed
+			instances, err := registry.ListInstancesCleaned(ctx)
+			if err == nil && len(instances) > 0 {
+				// ensureDefaultInstance logic will handle setting a new default
+				defaultInstance := registry.GetDefaultInstance()
+				if defaultInstance == address || defaultInstance == "" {
+					if len(instances) > 0 {
+						if err := registry.SetDefaultInstance(instances[0].Address); err == nil {
+							if Config.Verbose {
+								fmt.Printf("Updated default instance to: %s\n", instances[0].Address)
+							}
+						}
+					}
+				}
+			}
+
+			return nil
+		}
+	}
+
+	return fmt.Errorf("instance killed but failed to remove itself from registry within 5 seconds")
+}
+
+func startClineCore(corePort, hostPort int) (*exec.Cmd, error) {
+	if Config.Verbose {
+		fmt.Printf("Starting cline-core on port %d (with hostbridge on %d)\n", corePort, hostPort)
+	}
+
+	// Get the executable path and resolve symlinks (for npm global installs)
+	execPath, err := os.Executable()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get executable path: %w", err)
+	}
+
+	// Resolve symlinks to get the real path
+	// For npm global installs, execPath might be a symlink like:
+	// /opt/homebrew/bin/cline -> /opt/homebrew/lib/node_modules/cline/bin/cline
+	realPath, err := filepath.EvalSymlinks(execPath)
+	if err != nil {
+		// If we can't resolve symlinks, fall back to the original path
+		realPath = execPath
+		if Config.Verbose {
+			fmt.Printf("Warning: Could not resolve symlinks for %s: %v\n", execPath, err)
+		}
+	}
+
+	binDir := filepath.Dir(realPath)
+	installDir := filepath.Dir(binDir)
+	clineCorePath := filepath.Join(installDir, "cline-core.js")
+
+	if Config.Verbose {
+		fmt.Printf("Executable path: %s\n", execPath)
+		if realPath != execPath {
+			fmt.Printf("Real path (after resolving symlinks): %s\n", realPath)
+		}
+		fmt.Printf("Bin directory: %s\n", binDir)
+		fmt.Printf("Install directory: %s\n", installDir)
+		fmt.Printf("Looking for cline-core.js at: %s\n", clineCorePath)
+	}
+
+	// Check if cline-core.js exists at the primary location
+	var finalClineCorePath string
+	var finalInstallDir string
+	if _, err := os.Stat(clineCorePath); os.IsNotExist(err) {
+		// Development mode: Try ../../dist-standalone/cline-core.js
+		// This handles the case where we're running from cli/bin/cline
+		devClineCorePath := filepath.Join(binDir, "..", "..", "dist-standalone", "cline-core.js")
+		devInstallDir := filepath.Join(binDir, "..", "..", "dist-standalone")
+
+		if Config.Verbose {
+			fmt.Printf("Primary location not found, trying development path: %s\n", devClineCorePath)
+		}
+
+		if _, err := os.Stat(devClineCorePath); os.IsNotExist(err) {
+			return nil, fmt.Errorf("cline-core.js not found at '%s' or '%s'. Please ensure you're running from the correct location or reinstall with 'npm install -g cline'", clineCorePath, devClineCorePath)
+		}
+
+		finalClineCorePath = devClineCorePath
+		finalInstallDir = devInstallDir
+		if Config.Verbose {
+			fmt.Printf("Using development mode: cline-core.js found at %s\n", finalClineCorePath)
+		}
+	} else {
+		finalClineCorePath = clineCorePath
+		finalInstallDir = installDir
+		if Config.Verbose {
+			fmt.Printf("Using production mode: cline-core.js found at %s\n", finalClineCorePath)
+		}
+	}
+
+	// Create logs directory in ~/.cline/logs
+	logsDir := filepath.Join(Config.ConfigPath, "logs")
+	if err := os.MkdirAll(logsDir, 0755); err != nil {
+		return nil, fmt.Errorf("failed to create logs directory: %w", err)
+	}
+
+	// Create timestamped log file
+	timestamp := time.Now().Format("2006-01-02-15-04-05")
+	logFileName := fmt.Sprintf("cline-core-%s-localhost-%d.log", timestamp, corePort)
+	logFilePath := filepath.Join(logsDir, logFileName)
+	logFile, err := os.Create(logFilePath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create log file: %w", err)
+	}
+
+	// Start the cline-core process with --config flag using system node
+	args := []string{finalClineCorePath,
+		"--port", fmt.Sprintf("%d", corePort),
+		"--host-bridge-port", fmt.Sprintf("%d", hostPort),
+		"--config", Config.ConfigPath}
+
+	if Config.Verbose {
+		fmt.Printf("Using system node\n")
+	}
+
+	cmd := exec.Command("node", args...)
+
+	// Set working directory to installation root
+	cmd.Dir = finalInstallDir
+
+	// Redirect stdout and stderr to log file
+	cmd.Stdout = logFile
+	cmd.Stderr = logFile
+
+	// Put the child process in a new process group so Ctrl+C doesn't kill it
+	cmd.SysProcAttr = &syscall.SysProcAttr{
+	CreationFlags: syscall.CREATE_NEW_PROCESS_GROUP,
+	}
+
+	// Set environment variables with NODE_PATH for both real and fake node_modules
+	// The fake node_modules contains the vscode stub that can't be in the real node_modules
+	env := os.Environ()
+	realNodeModules := filepath.Join(finalInstallDir, "node_modules")
+	fakeNodeModules := filepath.Join(finalInstallDir, "fake_node_modules")
+	nodePath := fmt.Sprintf("%s%c%s", realNodeModules, os.PathListSeparator, fakeNodeModules)
+
+	env = append(env,
+		fmt.Sprintf("NODE_PATH=%s", nodePath),
+		// These control gRPC debug logging
+		//"GRPC_TRACE=all",
+		//"GRPC_VERBOSITY=DEBUG",
+		"NODE_ENV=development",
+	)
+	cmd.Env = env
+
+	if Config.Verbose {
+		fmt.Printf("NODE_PATH set to: %s\n", nodePath)
+	}
+
+	if err := cmd.Start(); err != nil {
+		logFile.Close()
+		return nil, fmt.Errorf("failed to start cline-core: %w", err)
+	}
+
+	if Config.Verbose {
+		fmt.Printf("Started cline-core (PID: %d)\n", cmd.Process.Pid)
+		fmt.Printf("Logging cline-core output to: %s\n", logFilePath)
+	}
+	return cmd, nil
+}

cli/pkg/cli/instances.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"os"
 	"strings"
-	"syscall"
 	"text/tabwriter"
 	"time"
 
@@ -247,28 +246,6 @@ type killResult struct {
 	err         error
 }
 
-func killInstanceProcess(ctx context.Context, registry *global.ClientRegistry, address string) killResult {
-	// Get gRPC client and process info
-	client, err := registry.GetClient(ctx, address)
-	if err != nil {
-		return killResult{address: address, alreadyDead: true, err: nil}
-	}
-
-	processInfo, err := client.State.GetProcessInfo(ctx, &cline.EmptyRequest{})
-	if err != nil {
-		return killResult{address: address, alreadyDead: true, err: nil}
-	}
-
-	pid := int(processInfo.ProcessId)
-
-	// Kill the process
-	if err := syscall.Kill(pid, syscall.SIGTERM); err != nil {
-		return killResult{address: address, pid: pid, err: err}
-	}
-
-	return killResult{address: address, pid: pid, err: nil}
-}
-
 func newInstanceListCommand() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:     "list",

cli/pkg/cli/sys-unix.go

@@ -0,0 +1,33 @@
+//go:build !windows
+
+package cli
+
+import (
+	"context"
+	"syscall"
+
+	"github.com/cline/cli/pkg/cli/global"
+	"github.com/cline/grpc-go/cline"
+)
+
+func killInstanceProcess(ctx context.Context, registry *global.ClientRegistry, address string) killResult {
+	// Get gRPC client and process info
+	client, err := registry.GetClient(ctx, address)
+	if err != nil {
+		return killResult{address: address, alreadyDead: true, err: nil}
+	}
+
+	processInfo, err := client.State.GetProcessInfo(ctx, &cline.EmptyRequest{})
+	if err != nil {
+		return killResult{address: address, alreadyDead: true, err: nil}
+	}
+
+	pid := int(processInfo.ProcessId)
+
+	// Kill the process
+	if err := syscall.Kill(pid, syscall.SIGTERM); err != nil {
+		return killResult{address: address, pid: pid, err: err}
+	}
+
+	return killResult{address: address, pid: pid, err: nil}
+}

cli/pkg/cli/sys-w32.go

@@ -0,0 +1,34 @@
+//go:build windows
+
+package cli
+
+import (
+	"context"
+	"syscall"
+
+	"github.com/cline/cli/pkg/cli/global"
+	"github.com/cline/grpc-go/cline"
+)
+
+
+func killInstanceProcess(ctx context.Context, registry *global.ClientRegistry, address string) killResult {
+	// Get gRPC client and process info
+	client, err := registry.GetClient(ctx, address)
+	if err != nil {
+		return killResult{address: address, alreadyDead: true, err: nil}
+	}
+
+	processInfo, err := client.State.GetProcessInfo(ctx, &cline.EmptyRequest{})
+	if err != nil {
+		return killResult{address: address, alreadyDead: true, err: nil}
+	}
+
+	pid := int(processInfo.ProcessId)
+
+	// Kill the process
+	if err := syscall.TerminateProcess(syscall.Handle(pid), 15); err != nil {
+		return killResult{address: address, pid: pid, err: err}
+	}
+
+	return killResult{address: address, pid:  pid, err: nil}
+}

package-lock.json

@@ -49,7 +49,8 @@
 				"@vscode/codicons": "^0.0.36",
 				"archiver": "^7.0.1",
 				"axios": "^1.12.0",
-				"better-sqlite3": "^12.4.1",
+				"better-sqlite3": "^12.5.0",
+				"better-sqlite3": "^12.5.0",
 				"cheerio": "^1.0.0",
 				"chokidar": "^4.0.1",
 				"chrome-launcher": "^1.1.2",
@@ -8081,9 +8082,12 @@
 			}
 		},
 		"node_modules/better-sqlite3": {
-			"version": "12.4.1",
-			"resolved": "https://registry.npmjs.org/better-sqlite3/-/better-sqlite3-12.4.1.tgz",
-			"integrity": "sha512-3yVdyZhklTiNrtg+4WqHpJpFDd+WHTg2oM7UcR80GqL05AOV0xEJzc6qNvFYoEtE+hRp1n9MpN6/+4yhlGkDXQ==",
+			"version": "12.5.0",
+			"resolved": "https://registry.npmjs.org/better-sqlite3/-/better-sqlite3-12.5.0.tgz",
+			"integrity": "sha512-WwCZ/5Diz7rsF29o27o0Gcc1Du+l7Zsv7SYtVPG0X3G/uUI1LqdxrQI7c9Hs2FWpqXXERjW9hp6g3/tH7DlVKg==",
+			"version": "12.5.0",
+			"resolved": "https://registry.npmjs.org/better-sqlite3/-/better-sqlite3-12.5.0.tgz",
+			"integrity": "sha512-WwCZ/5Diz7rsF29o27o0Gcc1Du+l7Zsv7SYtVPG0X3G/uUI1LqdxrQI7c9Hs2FWpqXXERjW9hp6g3/tH7DlVKg==",
 			"hasInstallScript": true,
 			"license": "MIT",
 			"dependencies": {
@@ -8091,7 +8095,8 @@
 				"prebuild-install": "^7.1.1"
 			},
 			"engines": {
-				"node": "20.x || 22.x || 23.x || 24.x"
+				"node": "20.x || 22.x || 23.x || 24.x || 25.x"
+				"node": "20.x || 22.x || 23.x || 24.x || 25.x"
 			}
 		},
 		"node_modules/big-integer": {

package.json

@@ -343,8 +343,8 @@
 		"compile": "npm run check-types && npm run lint && node esbuild.mjs",
 		"compile-standalone": "npm run check-types && npm run lint && node esbuild.mjs --standalone",
 		"compile-standalone-npm": "npm run protos && npm run protos-go && npm run check-types && npm run lint && node esbuild.mjs --standalone",
-		"compile-cli": "scripts/build-cli.sh",
-		"compile-cli-all-platforms": "scripts/build-cli-all-platforms.sh",
+		"compile-cli": "bash scripts/build-cli.sh",
+		"compile-cli-all-platforms": "bash scripts/build-cli-all-platforms.sh",
 		"compile-cli-man-page": "pandoc cli/man/cline.1.md -s -t man -o cli/man/cline.1",
 		"build:npm": "scripts/build-npm-package.sh",
 		"test:install": "bash scripts/test-install.sh",
@@ -492,7 +492,7 @@
 		"@vscode/codicons": "^0.0.36",
 		"archiver": "^7.0.1",
 		"axios": "^1.12.0",
-		"better-sqlite3": "^12.4.1",
+		"better-sqlite3": "^12.5.0",
 		"cheerio": "^1.0.0",
 		"chokidar": "^4.0.1",
 		"chrome-launcher": "^1.1.2",

scripts/build-cli-all-platforms.sh

@@ -25,6 +25,7 @@ cd cli
 
 # Define target platforms for cross-compilation
 PLATFORMS=(
+  "windows/amd64"
   "darwin/arm64"
   "darwin/amd64"
   "linux/amd64"

scripts/build-go-proto.mjs

@@ -5,6 +5,7 @@ import { execSync } from "child_process"
 import * as fs from "fs/promises"
 import { globby } from "globby"
 import { createRequire } from "module"
+import { platform } from "os"
 import * as path from "path"
 import { fileURLToPath } from "url"
 import { createServiceNameMap, parseProtoForServices } from "./proto-shared-utils.mjs"
@@ -51,12 +52,26 @@ function checkGoTool(toolName) {
 function installGoTools() {
 	console.log(chalk.yellow("Installing Go protobuf tools..."))
 
+	const OSPREFIX = (() => {
+		if (platform() === "win32") {
+			if (process.env.ComSpec) {
+				if (process.env.PSModulePath && !process.env.SHELL) {
+					return `$Env:GO111MODULE = "on";`
+				}
+				return `set GO111MODULE = "on" &`
+			}
+			return `export GO111MODULE = "on" &&`
+		} else {
+			return `GO111MODULE=on`
+		}
+	})()
+
 	const tools = ["google.golang.org/protobuf/cmd/protoc-gen-go@latest", "google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest"]
 
 	for (const tool of tools) {
 		try {
 			console.log(chalk.cyan(`Installing ${tool}...`))
-			execSync(`GO111MODULE=on go install ${tool}`, {
+			execSync(`${OSPREFIX} go install ${tool}`, {
 				stdio: "inherit",
 				env: { ...process.env, GO111MODULE: "on" },
 			})
@@ -573,7 +588,7 @@ ${methods}
 }
 
 // Main execution block - run if this script is executed directly
-if (import.meta.url === `file://${process.argv[1]}`) {
+if (fileURLToPath(import.meta.url) === process.argv[1]) {
 	async function main() {
 		try {
 			console.log(chalk.cyan("Starting Go protobuf code generation..."))

scripts/build-proto.mjs

@@ -12,7 +12,7 @@ import { main as generateHostBridgeClient } from "./generate-host-bridge-client.
 import { main as generateProtoBusSetup } from "./generate-protobus-setup.mjs"
 
 const require = createRequire(import.meta.url)
-const PROTOC = path.join(require.resolve("grpc-tools"), "../bin/protoc")
+const PROTOC = `"${path.join(require.resolve("grpc-tools"), "../bin/protoc")}"`
 
 const PROTO_DIR = path.resolve("proto")
 const TS_OUT_DIR = path.resolve("src/shared/proto")

scripts/install-local.sh

@@ -50,7 +50,13 @@ fi
 mkdir -p "$INSTALL_DIR/bin"
 
 # Copy standalone package first (includes node_modules, cline-core.js, etc.)
-rsync -a --exclude='bin' "$PROJECT_ROOT/dist-standalone/" "$INSTALL_DIR/"
+cp -r "$PROJECT_ROOT/dist-standalone/" "$INSTALL_DIR/"
+
+# Check if OS is windows
+WIN=false
+if [[ "$OSTYPE" == "msys" || "$OSTYPE" == "cygwin" || "$OSTYPE" == "win32" ]]; then
+    WIN=true
+fi
 
 # Detect platform for native modules
 os=$(uname -s | tr '[:upper:]' '[:lower:]')
@@ -59,17 +65,29 @@ if [[ "$arch" == "aarch64" ]]; then arch="arm64"; fi
 if [[ "$arch" == "x86_64" ]]; then arch="x64"; fi
 platform="$os-$arch"
 
+# Manually set platform to windows, as windows is tricky
+if [[ "$WIN" = true ]]; then
+    platform="win-$arch"
+fi
+
+echo -e "${CYAN}→${NC} ${DIM}Detected platform as $platform${NC}"
+
 # Copy platform-specific native modules (like better-sqlite3)
 if [ -d "$PROJECT_ROOT/dist-standalone/binaries/$platform/node_modules" ]; then
     echo -e "${CYAN}→${NC} ${DIM}Installing platform-specific modules for $platform${NC}"
     cp -r "$PROJECT_ROOT/dist-standalone/binaries/$platform/node_modules/"* "$INSTALL_DIR/node_modules/" 2>/dev/null || true
 fi
 
+
 # Copy binaries (this will create/overwrite the bin directory)
 mkdir -p "$INSTALL_DIR/bin"
-cp "$PROJECT_ROOT/cli/bin/cline" "$INSTALL_DIR/bin/"
-cp "$PROJECT_ROOT/cli/bin/cline-host" "$INSTALL_DIR/bin/"
-
+if [[ "$WIN" = true ]]; then
+    cp "$PROJECT_ROOT/cli/bin/cline-windows-amd64.exe" "$INSTALL_DIR/bin/cline.exe"
+    cp "$PROJECT_ROOT/cli/bin/cline-host-windows-amd64.exe" "$INSTALL_DIR/bin/cline-host.exe"
+else
+    cp "$PROJECT_ROOT/cli/bin/cline" "$INSTALL_DIR/bin/"
+    cp "$PROJECT_ROOT/cli/bin/cline-host" "$INSTALL_DIR/bin/"
+fi
 # Use system Node.js (symlink to avoid copying large binary)
 if command -v node >/dev/null 2>&1; then
     ln -sf "$(which node)" "$INSTALL_DIR/bin/node"
@@ -87,7 +105,11 @@ chmod +x "$INSTALL_DIR/bin/node" 2>/dev/null || true
 # Rebuild better-sqlite3 for system Node.js version
 echo -e "${CYAN}→${NC} ${DIM}Rebuilding native modules for Node.js $(node --version)...${NC}"
 cd "$INSTALL_DIR"
-npm rebuild better-sqlite3 > /dev/null 2>&1
+npm rebuild better-sqlite3
+
+mkdir -p "$INSTALL_DIR/dist-standalone/node_modules/better-sqlite3"
+cp -r "$INSTALL_DIR/node_modules/." "$INSTALL_DIR/dist-standalone/node_modules/better-sqlite3/"
+
 cd "$PROJECT_ROOT"
 echo -e "${GREEN}✓${NC} Native modules rebuilt"
 

scripts/install.sh

@@ -23,6 +23,13 @@ FORCE_INSTALL="${FORCE_INSTALL:-false}"
 os=$(uname -s | tr '[:upper:]' '[:lower:]')
 arch=$(uname -m)
 
+# Check if OS is windows
+WIN=false
+if [[ "$OSTYPE" == "msys" || "$OSTYPE" == "cygwin" || "$OSTYPE" == "win32" ]]; then
+    WIN=true
+    INSTALL_DIR="${CLINE_INSTALL_DIR:-$LOCALAPPDATA/.cline/cli}"
+fi
+
 # Normalize architecture names
 if [[ "$arch" == "aarch64" ]]; then
     arch="arm64"
@@ -47,8 +54,11 @@ case "$os" in
         platform="linux-$arch"
         ;;
     *)
+        [[ "$WIN" == true ]] || {
         echo -e "${RED}${BOLD}ERROR${NC} ${RED}Unsupported OS: $os${NC}" >&2
         exit 1
+        }
+        platform="win-$arch"
         ;;
 esac
 
@@ -369,9 +379,17 @@ install_cline() {
     
     # Extract package
     print_step "Extracting package"
-    if ! tar -xzf "$package_file" -C "$INSTALL_DIR" --strip-components=0; then
-        print_error "Failed to extract package"
-        exit 1
+   if ! tar -xzf "$package_file" -C "$INSTALL_DIR" --strip-components=0; then
+        if [[ "$WIN" == true ]]; then
+            echo -e "${RED}${BOLD}TAR command failed. Attempting backup method...${NC}"
+            if ! unzip -oq "$package_file" -d "$INSTALL_DIR"; then
+                print_error "Failed to extract package"
+                exit 1
+            fi
+        else
+            print_error "Failed to extract package"
+            exit 1
+        fi   
     fi
     
     # Make binaries executable

scripts/test-install.sh

@@ -63,7 +63,7 @@ echo ""
 
 # Test 4: Check for platform support
 echo "Test 4: Platform Support Check"
-platforms=("darwin-x64" "darwin-arm64" "linux-x64")
+platforms=("darwin-x64" "darwin-arm64" "linux-x64", "win-amd64")
 for platform in "${platforms[@]}"; do
     if grep -q "$platform" scripts/install.sh; then
         echo "  ✅ PASS: Platform '$platform' supported"