雷电芽衣
a7fc75bf6b
Add managed_runtime.go (paths, config validation, identity, runtime file changes, status checks) and shell_command.go (quoting, PowerShell encoding, command parsing) and move the four providers onto them. Claude-Session: https://claude.ai/code/session_01Agoc9bRVE9KL7mmWtey9Vq
120 lines
3.3 KiB
Go
120 lines
3.3 KiB
Go
package plugins
|
|
|
|
import (
|
|
"fmt"
|
|
"path/filepath"
|
|
"runtime"
|
|
"strings"
|
|
)
|
|
|
|
type kimiRuntimeReference struct {
|
|
agentID string
|
|
scriptPath string
|
|
}
|
|
|
|
func sameKimiPath(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 sameKimiAgentID(left, right string) bool {
|
|
if runtime.GOOS == "windows" {
|
|
return strings.EqualFold(left, right)
|
|
}
|
|
return left == right
|
|
}
|
|
|
|
func buildKimiCommand(runtimePath, scriptPath string) (string, error) {
|
|
if !filepath.IsAbs(runtimePath) || !filepath.IsAbs(scriptPath) {
|
|
return "", fmt.Errorf("kimi hook commands require absolute runtime and script paths")
|
|
}
|
|
if runtime.GOOS == "windows" {
|
|
return encodedWindowsCommand(runtimePath, scriptPath), nil
|
|
}
|
|
return quotePOSIXArgument(runtimePath) + " " + quotePOSIXArgument(scriptPath), nil
|
|
}
|
|
|
|
func readKimiLegacyWindowsArgument(command string, start int) (string, int, bool) {
|
|
if start >= len(command) {
|
|
return "", start, false
|
|
}
|
|
if command[start] == '"' {
|
|
closing := strings.IndexByte(command[start+1:], '"')
|
|
if closing < 0 {
|
|
return "", start, false
|
|
}
|
|
closing += start + 1
|
|
return command[start+1 : closing], closing + 1, true
|
|
}
|
|
end := start
|
|
for end < len(command) && command[end] != ' ' {
|
|
if command[end] == '"' || command[end] == '\t' || command[end] == '\r' || command[end] == '\n' {
|
|
return "", start, false
|
|
}
|
|
end++
|
|
}
|
|
return command[start:end], end, end > start
|
|
}
|
|
|
|
func parseKimiLegacyWindowsCommand(command string) (string, string, bool) {
|
|
runtimePath, next, ok := readKimiLegacyWindowsArgument(command, 0)
|
|
if !ok || next >= len(command) || command[next] != ' ' {
|
|
return "", "", false
|
|
}
|
|
scriptPath, end, ok := readKimiLegacyWindowsArgument(command, next+1)
|
|
if !ok || end != len(command) {
|
|
return "", "", false
|
|
}
|
|
expected := quoteWindowsArgument(runtimePath) + " " + quoteWindowsArgument(scriptPath)
|
|
return runtimePath, scriptPath, command == expected
|
|
}
|
|
|
|
func parseKimiCommand(command string) (string, string, bool) {
|
|
if runtimePath, scriptPath, ok := parsePOSIXCommand(command); ok {
|
|
return runtimePath, scriptPath, true
|
|
}
|
|
if runtimePath, scriptPath, ok := parseEncodedWindowsCommand(command); ok {
|
|
return runtimePath, scriptPath, true
|
|
}
|
|
return parseKimiLegacyWindowsCommand(command)
|
|
}
|
|
|
|
func isKimiNodeExecutable(path string) bool {
|
|
name := filepath.Base(path)
|
|
return name == "node" || strings.EqualFold(name, "node.exe")
|
|
}
|
|
|
|
func kimiRuntimeReferenceForCommand(
|
|
command string,
|
|
scriptName string,
|
|
) (*kimiRuntimeReference, error) {
|
|
runtimePath, scriptPath, ok := parseKimiCommand(command)
|
|
if !ok || !filepath.IsAbs(runtimePath) || !filepath.IsAbs(scriptPath) ||
|
|
!isKimiNodeExecutable(runtimePath) || filepath.Base(scriptPath) != scriptName {
|
|
return nil, nil
|
|
}
|
|
agentDirectory := filepath.Dir(scriptPath)
|
|
runtimeRoot, err := AgentRuntimeRoot()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if !sameKimiPath(filepath.Dir(agentDirectory), runtimeRoot) {
|
|
return nil, nil
|
|
}
|
|
agentID := filepath.Base(agentDirectory)
|
|
if agentID == "" || agentID == "." || agentID == ".." {
|
|
return nil, nil
|
|
}
|
|
return &kimiRuntimeReference{agentID: agentID, scriptPath: scriptPath}, nil
|
|
}
|