feat: add native Factory Droid hook integration
This commit is contained in:
ZacharyZhang-NY committed
1 parent
2eff1ae119
commit
577e3609b5
13 files changed
+2292
-1
No files matched your search
@@ -0,0 +1,300 @@
|
||||
package plugins
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"errors"
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"sort"
|
||||
)
|
||||
|
||||
type droidDocument struct {
|
||||
kind string
|
||||
filePath string
|
||||
exists bool
|
||||
raw []byte
|
||||
hooks droidHookSettings
|
||||
basePath []any
|
||||
hasHooksContainer bool
|
||||
ownedFile bool
|
||||
}
|
||||
|
||||
type droidSources struct {
|
||||
rootPath string
|
||||
primary *droidDocument
|
||||
settings *droidDocument
|
||||
}
|
||||
|
||||
type droidInstallationTargets struct {
|
||||
targets map[string]*droidDocument
|
||||
createdRoot *droidDocument
|
||||
}
|
||||
|
||||
type droidRenderedDocument struct {
|
||||
document *droidDocument
|
||||
changed bool
|
||||
next []byte
|
||||
remove bool
|
||||
}
|
||||
|
||||
func droidFactoryPaths() (string, string, string, error) {
|
||||
home, err := os.UserHomeDir()
|
||||
if err != nil {
|
||||
return "", "", "", fmt.Errorf("resolve home directory: %w", err)
|
||||
}
|
||||
directory := filepath.Join(home, ".factory")
|
||||
return filepath.Join(directory, "hooks.json"),
|
||||
filepath.Join(directory, "hooks", "hooks.json"),
|
||||
filepath.Join(directory, "settings.json"), nil
|
||||
}
|
||||
|
||||
func readDroidSources() (*droidSources, error) {
|
||||
rootPath, legacyPath, settingsPath, err := droidFactoryPaths()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
rootRaw, rootExists, err := readDroidOptional(rootPath, "Factory Droid hooks")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
var primary *droidDocument
|
||||
if rootExists {
|
||||
primary, err = parseDroidDocument(true, rootPath, "hooks", rootRaw)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
} else {
|
||||
legacyRaw, legacyExists, readErr := readDroidOptional(legacyPath, "Factory Droid legacy hooks")
|
||||
if readErr != nil {
|
||||
return nil, readErr
|
||||
}
|
||||
if legacyExists {
|
||||
primary, err = parseDroidDocument(true, legacyPath, "legacy", legacyRaw)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
}
|
||||
settingsRaw, settingsExists, err := readDroidOptional(settingsPath, "Factory Droid settings")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
var settings *droidDocument
|
||||
if settingsExists {
|
||||
settings, err = parseDroidDocument(true, settingsPath, "settings", settingsRaw)
|
||||
} else {
|
||||
settings, err = parseDroidDocument(false, settingsPath, "settings", []byte("{}\n"))
|
||||
}
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &droidSources{rootPath: rootPath, primary: primary, settings: settings}, nil
|
||||
}
|
||||
|
||||
func parseDroidDocument(exists bool, filePath, kind string, raw []byte) (*droidDocument, error) {
|
||||
label := droidDocumentLabel(kind, filePath)
|
||||
root, err := decodeDroidJSONCObject(raw, label)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
document := &droidDocument{
|
||||
kind: kind, filePath: filePath, exists: exists, raw: append([]byte(nil), raw...),
|
||||
}
|
||||
if kind == "settings" {
|
||||
hooksValue, hasHooks := root["hooks"]
|
||||
document.basePath = []any{"hooks"}
|
||||
document.hasHooksContainer = hasHooks
|
||||
if !hasHooks {
|
||||
document.hooks = droidHookSettings{}
|
||||
return document, nil
|
||||
}
|
||||
document.hooks, err = readDroidHookSettings(hooksValue, label+` field "hooks"`)
|
||||
return document, err
|
||||
}
|
||||
document.hooks, err = readDroidHookSettings(root, label)
|
||||
document.hasHooksContainer = true
|
||||
document.ownedFile = bytes.HasPrefix(raw, []byte(droidOwnedFileMarker))
|
||||
return document, err
|
||||
}
|
||||
|
||||
func droidDocumentLabel(kind, filePath string) string {
|
||||
switch kind {
|
||||
case "settings":
|
||||
return fmt.Sprintf("Factory Droid settings at %s", filePath)
|
||||
case "legacy":
|
||||
return fmt.Sprintf("Factory Droid legacy hooks at %s", filePath)
|
||||
default:
|
||||
return fmt.Sprintf("Factory Droid hooks at %s", filePath)
|
||||
}
|
||||
}
|
||||
|
||||
func createOwnedDroidDocument(filePath string) (*droidDocument, error) {
|
||||
return parseDroidDocument(
|
||||
false, filePath, "hooks", []byte(droidOwnedFileMarker+"\n{}\n"),
|
||||
)
|
||||
}
|
||||
|
||||
func selectDroidInstallationTargets(sources *droidSources) (*droidInstallationTargets, error) {
|
||||
selection := &droidInstallationTargets{targets: make(map[string]*droidDocument, len(droidToolEvents))}
|
||||
for _, event := range droidToolEvents {
|
||||
switch {
|
||||
case sources.primary != nil && hasDroidHookField(sources.primary.hooks, event):
|
||||
selection.targets[event] = sources.primary
|
||||
case sources.settings.hasHooksContainer && hasDroidHookField(sources.settings.hooks, event):
|
||||
selection.targets[event] = sources.settings
|
||||
case sources.primary != nil:
|
||||
selection.targets[event] = sources.primary
|
||||
case sources.settings.hasHooksContainer:
|
||||
selection.targets[event] = sources.settings
|
||||
default:
|
||||
if selection.createdRoot == nil {
|
||||
created, err := createOwnedDroidDocument(sources.rootPath)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
selection.createdRoot = created
|
||||
}
|
||||
selection.targets[event] = selection.createdRoot
|
||||
}
|
||||
}
|
||||
return selection, nil
|
||||
}
|
||||
|
||||
func hasDroidHookField(settings droidHookSettings, key string) bool {
|
||||
_, exists := settings[key]
|
||||
return exists
|
||||
}
|
||||
|
||||
func uniqueDroidDocuments(documents ...*droidDocument) []*droidDocument {
|
||||
result := make([]*droidDocument, 0, len(documents))
|
||||
seen := map[string]bool{}
|
||||
for _, document := range documents {
|
||||
if document == nil {
|
||||
continue
|
||||
}
|
||||
normalized := filepath.Clean(document.filePath)
|
||||
if seen[normalized] {
|
||||
continue
|
||||
}
|
||||
seen[normalized] = true
|
||||
result = append(result, document)
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
func droidAdditionsFor(
|
||||
document *droidDocument,
|
||||
targets map[string]*droidDocument,
|
||||
groups map[string]map[string]any,
|
||||
) map[string]map[string]any {
|
||||
additions := map[string]map[string]any{}
|
||||
for _, event := range droidToolEvents {
|
||||
if sameDroidPath(targets[event].filePath, document.filePath) {
|
||||
additions[event] = groups[event]
|
||||
}
|
||||
}
|
||||
return additions
|
||||
}
|
||||
|
||||
func renderDroidDocument(
|
||||
document *droidDocument,
|
||||
agentID, runtimeRoot string,
|
||||
additions map[string]map[string]any,
|
||||
) (*droidRenderedDocument, error) {
|
||||
editor, err := newDroidJSONCEditor(document.raw, droidDocumentLabel(document.kind, document.filePath))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
removals := managedDroidRemovals(document.hooks, agentID, runtimeRoot)
|
||||
sort.SliceStable(removals, func(left, right int) bool {
|
||||
if removals[left].event == removals[right].event {
|
||||
return removals[left].groupIndex > removals[right].groupIndex
|
||||
}
|
||||
return removals[left].event < removals[right].event
|
||||
})
|
||||
for _, removal := range removals {
|
||||
groupPath := appendDroidPath(document.basePath, removal.event, removal.groupIndex)
|
||||
if removal.removeGroup {
|
||||
if err := editor.remove(groupPath); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
continue
|
||||
}
|
||||
sort.Sort(sort.Reverse(sort.IntSlice(removal.handlerIndexes)))
|
||||
for _, handlerIndex := range removal.handlerIndexes {
|
||||
if err := editor.remove(appendDroidPath(groupPath, "hooks", handlerIndex)); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
}
|
||||
current, err := parseDroidDocument(document.exists, document.filePath, document.kind, editor.pack())
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if document.ownedFile {
|
||||
for _, event := range droidToolEvents {
|
||||
groups, exists := current.hooks[event].([]any)
|
||||
if exists && len(groups) == 0 {
|
||||
if err := editor.remove(appendDroidPath(document.basePath, event)); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for _, event := range droidToolEvents {
|
||||
group, exists := additions[event]
|
||||
if !exists {
|
||||
continue
|
||||
}
|
||||
current, err = parseDroidDocument(document.exists, document.filePath, document.kind, editor.pack())
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
eventPath := appendDroidPath(document.basePath, event)
|
||||
if hasDroidHookField(current.hooks, event) {
|
||||
err = editor.appendArray(eventPath, group)
|
||||
} else {
|
||||
err = editor.addProperty(document.basePath, event, []any{group})
|
||||
}
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
next := editor.pack()
|
||||
nextDocument, err := parseDroidDocument(document.exists, document.filePath, document.kind, next)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
remove := len(additions) == 0 && document.ownedFile && document.kind != "settings" && len(nextDocument.hooks) == 0
|
||||
return &droidRenderedDocument{
|
||||
document: document, changed: remove || !bytes.Equal(next, document.raw), next: next, remove: remove,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func appendDroidPath(base []any, parts ...any) []any {
|
||||
path := make([]any, 0, len(base)+len(parts))
|
||||
path = append(path, base...)
|
||||
return append(path, parts...)
|
||||
}
|
||||
|
||||
func displayDroidConfigPath(sources *droidSources) string {
|
||||
if sources.primary != nil {
|
||||
return sources.primary.filePath
|
||||
}
|
||||
if sources.settings.exists && sources.settings.hasHooksContainer {
|
||||
return sources.settings.filePath
|
||||
}
|
||||
return sources.rootPath
|
||||
}
|
||||
|
||||
func readDroidOptional(path, label string) ([]byte, bool, error) {
|
||||
raw, err := os.ReadFile(path) // #nosec G304 -- paths are fixed user-level Factory configuration paths.
|
||||
if err == nil {
|
||||
return raw, true, nil
|
||||
}
|
||||
if errors.Is(err, os.ErrNotExist) {
|
||||
return nil, false, nil
|
||||
}
|
||||
return nil, false, fmt.Errorf("read %s at %s: %w", label, path, err)
|
||||
}
|
||||
Reference in new issue
Block a user