133 lines
3.5 KiB
Go
133 lines
3.5 KiB
Go
package plugins
|
|
|
|
import (
|
|
"fmt"
|
|
"path/filepath"
|
|
"runtime"
|
|
"strings"
|
|
)
|
|
|
|
type grokRuntimeReference struct {
|
|
agentID string
|
|
scriptPath string
|
|
}
|
|
|
|
func sameGrokPath(left, right string) bool {
|
|
left = filepath.Clean(left)
|
|
right = filepath.Clean(right)
|
|
if absolute, err := filepath.Abs(left); err == nil {
|
|
left = absolute
|
|
}
|
|
if absolute, err := filepath.Abs(right); err == nil {
|
|
right = absolute
|
|
}
|
|
if runtime.GOOS == "windows" {
|
|
return strings.EqualFold(left, right)
|
|
}
|
|
return left == right
|
|
}
|
|
|
|
func sameGrokAgentID(left, right string) bool {
|
|
if runtime.GOOS == "windows" {
|
|
return strings.EqualFold(left, right)
|
|
}
|
|
return left == right
|
|
}
|
|
|
|
func buildGrokCommand(runtimePath, scriptPath string) (string, error) {
|
|
if !filepath.IsAbs(runtimePath) || !filepath.IsAbs(scriptPath) {
|
|
return "", fmt.Errorf(
|
|
"Grok hook commands require absolute runtime and script paths",
|
|
)
|
|
}
|
|
if runtime.GOOS == "windows" {
|
|
return codexWindowsCommand(runtimePath, scriptPath), nil
|
|
}
|
|
return quotePOSIXArgument(runtimePath) + " " + quotePOSIXArgument(scriptPath), nil
|
|
}
|
|
|
|
func quoteGrokLegacyWindowsArgument(value string) string {
|
|
return `"` + strings.ReplaceAll(value, `"`, `\"`) + `"`
|
|
}
|
|
|
|
func readGrokLegacyWindowsArgument(
|
|
command string,
|
|
start int,
|
|
) (string, int, bool) {
|
|
if start >= len(command) || command[start] != '"' {
|
|
return "", start, false
|
|
}
|
|
var value strings.Builder
|
|
for index := start + 1; index < len(command); index++ {
|
|
if command[index] == '"' {
|
|
return value.String(), index + 1, true
|
|
}
|
|
if command[index] == '\r' || command[index] == '\n' {
|
|
return "", start, false
|
|
}
|
|
value.WriteByte(command[index])
|
|
}
|
|
return "", start, false
|
|
}
|
|
|
|
func parseGrokLegacyWindowsCommand(command string) (string, string, bool) {
|
|
runtimePath, next, ok := readGrokLegacyWindowsArgument(command, 0)
|
|
if !ok || next >= len(command) || command[next] != ' ' {
|
|
return "", "", false
|
|
}
|
|
scriptPath, end, ok := readGrokLegacyWindowsArgument(command, next+1)
|
|
if !ok || end != len(command) {
|
|
return "", "", false
|
|
}
|
|
expected := quoteGrokLegacyWindowsArgument(runtimePath) + " " +
|
|
quoteGrokLegacyWindowsArgument(scriptPath)
|
|
return runtimePath, scriptPath, command == expected
|
|
}
|
|
|
|
func parseGrokCommand(command string) (string, string, bool) {
|
|
if runtimePath, scriptPath, ok := parseCodexPOSIXCommand(command); ok {
|
|
return runtimePath, scriptPath, true
|
|
}
|
|
if runtimePath, scriptPath, ok := parseCodexWindowsCommand(command); ok {
|
|
return runtimePath, scriptPath, true
|
|
}
|
|
return parseGrokLegacyWindowsCommand(command)
|
|
}
|
|
|
|
func isGrokNodeExecutable(path string) bool {
|
|
name := filepath.Base(path)
|
|
return name == "node" || strings.EqualFold(name, "node.exe")
|
|
}
|
|
|
|
func grokRuntimeReferenceForCommand(
|
|
command string,
|
|
scriptName string,
|
|
) (*grokRuntimeReference, error) {
|
|
runtimePath, scriptPath, ok := parseGrokCommand(command)
|
|
if !ok || !filepath.IsAbs(runtimePath) || !filepath.IsAbs(scriptPath) ||
|
|
!isGrokNodeExecutable(runtimePath) ||
|
|
!sameGrokFileName(filepath.Base(scriptPath), scriptName) {
|
|
return nil, nil
|
|
}
|
|
agentDirectory := filepath.Dir(scriptPath)
|
|
runtimeRoot, err := AgentRuntimeRoot()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if !sameGrokPath(filepath.Dir(agentDirectory), runtimeRoot) {
|
|
return nil, nil
|
|
}
|
|
agentID := filepath.Base(agentDirectory)
|
|
if agentID == "" || agentID == "." || agentID == ".." {
|
|
return nil, nil
|
|
}
|
|
return &grokRuntimeReference{agentID: agentID, scriptPath: scriptPath}, nil
|
|
}
|
|
|
|
func sameGrokFileName(left, right string) bool {
|
|
if runtime.GOOS == "windows" {
|
|
return strings.EqualFold(left, right)
|
|
}
|
|
return left == right
|
|
}
|