Files
kandev/apps/backend/internal/agent/runtime/lifecycle/wake_payload_env.go
T
2026-06-11 22:25:58 +01:00

166 lines
4.4 KiB
Go

package lifecycle
import (
"errors"
"fmt"
"os"
"path/filepath"
"strings"
"syscall"
"unicode"
"go.uber.org/zap"
)
const (
envWakePayloadJSON = "KANDEV_WAKE_PAYLOAD_JSON"
envWakePayloadPath = "KANDEV_WAKE_PAYLOAD_PATH"
envWakePayloadInlineMax = 64 * 1024
wakePayloadDirRel = ".kandev/wake-payloads"
wakePayloadExcludeLine = ".kandev/wake-payloads/"
defaultWakePayloadFileID = "payload"
)
func spillLargeWakePayloadEnv(env map[string]string, workspacePath string, log *zap.Logger) error {
payload := env[envWakePayloadJSON]
if payload == "" || len(payload) <= envWakePayloadInlineMax {
return nil
}
fileID := sanitizeWakePayloadFileID(env["KANDEV_RUN_ID"])
if fileID == defaultWakePayloadFileID && log != nil {
log.Warn("KANDEV_RUN_ID is missing or empty; spill file may collide across runs",
zap.String("payload_path", filepath.Join(wakePayloadDirRel, fileID+".json")))
}
if workspacePath == "" {
return fmt.Errorf("%s is %d bytes, above %d byte inline limit, but workspace path is empty",
envWakePayloadJSON, len(payload), envWakePayloadInlineMax)
}
relPath := filepath.ToSlash(filepath.Join(wakePayloadDirRel, fileID+".json"))
absPath := filepath.Join(workspacePath, filepath.FromSlash(relPath))
if err := os.MkdirAll(filepath.Dir(absPath), 0o700); err != nil {
return fmt.Errorf("create wake payload directory: %w", err)
}
if err := os.WriteFile(absPath, []byte(payload), 0o600); err != nil {
_ = os.Remove(absPath)
return fmt.Errorf("write wake payload file: %w", err)
}
delete(env, envWakePayloadJSON)
env[envWakePayloadPath] = relPath
if err := ensureWakePayloadGitExclude(workspacePath); err != nil && log != nil {
log.Warn("failed to update git exclude for wake payload spill file",
zap.String("workspace_path", workspacePath),
zap.Error(err))
}
if log != nil {
log.Info("spilled oversized wake payload env to workspace file",
zap.Int("payload_bytes", len(payload)),
zap.String("payload_path", relPath))
}
return nil
}
func sanitizeWakePayloadFileID(id string) string {
id = strings.TrimSpace(id)
if id == "" {
return defaultWakePayloadFileID
}
var b strings.Builder
for _, r := range id {
if unicode.IsLetter(r) || unicode.IsDigit(r) || r == '-' || r == '_' {
b.WriteRune(r)
}
}
if b.Len() == 0 {
return defaultWakePayloadFileID
}
return b.String()
}
func ensureWakePayloadGitExclude(workspacePath string) error {
infoDir, err := gitInfoDir(workspacePath)
if err != nil {
return err
}
if infoDir == "" {
return nil
}
if err := os.MkdirAll(infoDir, 0o700); err != nil {
return err
}
excludePath := filepath.Join(infoDir, "exclude")
data, err := os.ReadFile(excludePath)
if err != nil && !os.IsNotExist(err) {
return err
}
if strings.Contains(string(data), wakePayloadExcludeLine) {
return nil
}
prefix := ""
if len(data) > 0 && !strings.HasSuffix(string(data), "\n") {
prefix = "\n"
}
return os.WriteFile(excludePath, append(data, []byte(prefix+wakePayloadExcludeLine+"\n")...), 0o600)
}
func gitInfoDir(workspacePath string) (string, error) {
gitPath := filepath.Join(workspacePath, ".git")
if infoDir, err := gitDirInfo(gitPath); err != nil || infoDir != "" {
return infoDir, err
}
return gitWorktreeInfo(workspacePath, gitPath)
}
func gitDirInfo(gitPath string) (string, error) {
infoPath := filepath.Join(gitPath, "info")
st, err := os.Stat(infoPath)
if err == nil {
if st.IsDir() {
return infoPath, nil
}
return "", nil
}
if os.IsNotExist(err) || errors.Is(err, syscall.ENOTDIR) {
if fi, statErr := os.Stat(gitPath); statErr == nil && fi.IsDir() {
return infoPath, nil
}
return "", nil
}
return "", err
}
func gitWorktreeInfo(workspacePath string, gitPath string) (string, error) {
data, err := os.ReadFile(gitPath)
if os.IsNotExist(err) {
return "", nil
}
if err != nil {
return "", err
}
const prefix = "gitdir:"
line := strings.TrimSpace(string(data))
if !strings.HasPrefix(line, prefix) {
return "", nil
}
gitDir := strings.TrimSpace(strings.TrimPrefix(line, prefix))
if gitDir == "" {
return "", nil
}
if !filepath.IsAbs(gitDir) {
gitDir = filepath.Join(workspacePath, gitDir)
}
infoDir := filepath.Join(filepath.Clean(gitDir), "info")
st, err := os.Stat(infoDir)
switch {
case os.IsNotExist(err):
return infoDir, nil
case err != nil:
return "", err
case !st.IsDir():
return "", fmt.Errorf("git info path is not a directory: %s", infoDir)
}
return infoDir, nil
}