114 lines
3.0 KiB
Go
114 lines
3.0 KiB
Go
package plugins
|
|
|
|
import "fmt"
|
|
|
|
// GrokPlugin manages Grok Build native global user hooks.
|
|
type GrokPlugin struct{}
|
|
|
|
func (p *GrokPlugin) Install(config InstallConfig) error {
|
|
if config.AgentID == "" {
|
|
return fmt.Errorf("agent ID is required")
|
|
}
|
|
document, err := readGrokConfig()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if config.GuardScriptPath == "" {
|
|
return fmt.Errorf("guard script path is required")
|
|
}
|
|
guardExists, err := regularFileExists(config.GuardScriptPath, "Elydora guard runtime")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !guardExists {
|
|
return fmt.Errorf("Elydora guard runtime is missing: %s", config.GuardScriptPath)
|
|
}
|
|
hookPath, err := hookScriptPath(config.AgentID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if config.HookScript != "" {
|
|
hookPath = config.HookScript
|
|
}
|
|
nodePath, err := resolveNodeRuntime()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
runtimeRoot, err := grokRuntimeRoot()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
hooks, _ := removeManagedGrokHooks(document.hooks, "", runtimeRoot)
|
|
hooks["PreToolUse"] = append(hooks["PreToolUse"], buildGrokGroup(
|
|
buildGrokHandler(buildGrokCommand(nodePath, config.GuardScriptPath)),
|
|
))
|
|
hooks["PostToolUse"] = append(hooks["PostToolUse"], buildGrokGroup(
|
|
buildGrokHandler(buildGrokCommand(nodePath, hookPath)),
|
|
))
|
|
next := cloneGrokObject(document.root)
|
|
next["hooks"] = renderGrokHooks(hooks)
|
|
|
|
runtimeConfig := config
|
|
runtimeConfig.AgentName = grokAgentKey
|
|
if err := GenerateHookScript(hookPath, runtimeConfig); err != nil {
|
|
return fmt.Errorf("generate hook script: %w", err)
|
|
}
|
|
if err := writeHookJSONObjectAtomic(document.configPath, next); err != nil {
|
|
return fmt.Errorf("write Grok hooks config: %w", err)
|
|
}
|
|
fmt.Println("Grok Build: global PreToolUse and PostToolUse hooks installed.")
|
|
return nil
|
|
}
|
|
|
|
func (p *GrokPlugin) Uninstall(agentID string) error {
|
|
document, err := readGrokConfig()
|
|
if err != nil || !document.exists {
|
|
return err
|
|
}
|
|
runtimeRoot, err := grokRuntimeRoot()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
hooks, changed := removeManagedGrokHooks(document.hooks, agentID, runtimeRoot)
|
|
if !changed {
|
|
return nil
|
|
}
|
|
next := cloneGrokObject(document.root)
|
|
if len(hooks) == 0 {
|
|
delete(next, "hooks")
|
|
} else {
|
|
next["hooks"] = renderGrokHooks(hooks)
|
|
}
|
|
if len(next) == 0 {
|
|
return removeHookFile(document.configPath, "Grok hooks config")
|
|
}
|
|
return writeHookJSONObjectAtomic(document.configPath, next)
|
|
}
|
|
|
|
func (p *GrokPlugin) Status() (PluginStatus, error) {
|
|
document, err := readGrokConfig()
|
|
status := PluginStatus{
|
|
AgentName: grokAgentKey,
|
|
DisplayName: "Grok Build",
|
|
ConfigPath: document.configPath,
|
|
}
|
|
if err != nil {
|
|
return status, err
|
|
}
|
|
runtimeRoot, err := grokRuntimeRoot()
|
|
if err != nil {
|
|
return status, err
|
|
}
|
|
contracts := grokRuntimeContracts(document.hooks, runtimeRoot)
|
|
if len(contracts) == 0 {
|
|
return status, nil
|
|
}
|
|
status.HookConfigured = true
|
|
status.HookScriptExists, err = grokRuntimeScriptsExist(contracts, runtimeRoot)
|
|
if err != nil {
|
|
return status, err
|
|
}
|
|
status.Installed = status.HookScriptExists
|
|
return status, nil
|
|
}
|