Windows script requires escape special chars to run successfully

[windar022]

Expected Behavior

Windows and Linux script should behave the same way when you are writing the scripts. Windows should not require to escape special chars.

Actual Behavior

Windows and Linux scripts are considering different validations about escaping chars

For example for windows you need to create the script as follow, if not the var are going to be added to the file as an empty value:

#!win powershell.exe -File
`$text="some value"
echo `$text

For Linux cases it is not necessary to keep escaping char, so the coding is more natural.

Steps to Reproduce the Problem

kind: Task
metadata:
  name: example-task-name
spec:
  steps:
    - name: powershell
      image: mcr.microsoft.com/powershell
      script: |
        #!win powershell.exe -File
        $text="some value"
        echo $text

Additional Info

A possible solution is to encode the script before create the file, like the non windows script logic https://github.com/tektoncd/pipeline/blob/main/pkg/pod/script.go#L189

When a script requires windows, the script can be encoded and then create the output file command like the following example:
https://github.com/tektoncd/pipeline/blob/main/pkg/pod/script.go#L177C3-L180C23

script = encodeScript(script)
initContainer.Args[1] += fmt.Sprintf(`[System.Text.Encoding]::UTF8.GetString([Convert]::FromBase64String("%s")) | Out-File -FilePath %s`, script, scriptFile)

• Kubernetes version:

v1.27.9

• Tekton Pipeline version:

v0.56.1

[ljluestc]

// pkg/pod/script.go
package pod

import (
	"encoding/base64"
	"fmt"
	"path/filepath"
	"strings"

	"github.com/tektoncd/pipeline/pkg/apis/pipeline/v1beta1"
	corev1 "k8s.io/api/core/v1"
)

// ScriptHandler handles script execution for steps.
type ScriptHandler struct{}

// encodeScript encodes the script content to Base64 to handle special characters safely.
func encodeScript(script string) string {
	return base64.StdEncoding.EncodeToString([]byte(script))
}

// MakeInitContainer creates an init container to write the script to a file.
func (h *ScriptHandler) MakeInitContainer(step v1beta1.Step, workspaceDir string) (corev1.Container, error) {
	script := step.Script
	if script == "" {
		return corev1.Container{}, fmt.Errorf("step script is empty")
	}

	// Determine the script file path and shebang
	scriptFile := filepath.Join(workspaceDir, "script.sh")
	shebang := strings.SplitN(script, "\n", 2)[0]
	isWindows := strings.HasPrefix(shebang, "#!win")

	if isWindows {
		// For Windows, use a .ps1 file and PowerShell
		scriptFile = filepath.Join(workspaceDir, "script.ps1")
		// Remove the shebang line for Windows
		if len(strings.SplitN(script, "\n", 2)) > 1 {
			script = strings.SplitN(script, "\n", 2)[1]
		}
	}

	// Encode the script to Base64 to handle special characters
	encodedScript := encodeScript(script)

	// Create the init container to write the script
	args := []string{
		"-c",
		"",
	}

	if isWindows {
		// For Windows, decode Base64 and write to .ps1 file with UTF-8 encoding
		args[1] = fmt.Sprintf(
			`[System.Text.Encoding]::UTF8.GetString([Convert]::FromBase64String("%s")) | Out-File -FilePath %s -Encoding UTF8`,
			encodedScript, scriptFile,
		)
	} else {
		// For Linux, write the script directly (with shebang)
		args[1] = fmt.Sprintf(`echo %s | base64 -d > %s && chmod +x %s`, encodedScript, scriptFile, scriptFile)
	}

	return corev1.Container{
		Name:    "init-script-" + step.Name,
		Image:   "bash", // Use a lightweight image with bash for Linux, or PowerShell for Windows
		Command: []string{"/bin/sh"},
		Args:    args,
		VolumeMounts: []corev1.VolumeMount{
			{
				Name:      "workspace",
				MountPath: workspaceDir,
			},
		},
	}, nil
}

// MakeStepContainer modifies the step container to execute the script.
func (h *ScriptHandler) MakeStepContainer(step v1beta1.Step, workspaceDir string) (corev1.Container, error) {
	scriptFile := filepath.Join(workspaceDir, "script.sh")
	shebang := strings.SplitN(step.Script, "\n", 2)[0]
	isWindows := strings.HasPrefix(shebang, "#!win")

	if isWindows {
		scriptFile = filepath.Join(workspaceDir, "script.ps1")
	}

	container := corev1.Container{
		Name:         step.Name,
		Image:        step.Image,
		Command:      step.Command,
		Args:         step.Args,
		VolumeMounts: step.VolumeMounts,
	}

	if isWindows {
		// For Windows, execute the PowerShell script
		container.Command = []string{"powershell.exe"}
		container.Args = []string{"-File", scriptFile}
	} else {
		// For Linux, execute the shell script
		container.Command = []string{"/bin/sh"}
		container.Args = []string{scriptFile}
	}

	return container, nil
}