Skip to content

The cross-harness, self-improving memory layer for AI agents. Join our community: https://discord.com/invite/zdNChS2fBu

9.8 KB
Raw Blame
package hooks

import (
	"bytes"
	"encoding/json"
	"os"

	"github.com/asymptote-labs/agent-beacon/pkg/asymptoteobserve/hookcmd"
)

// settingsHookGroup and settingsHookRef model the shape Beacon writes into a runtime's shared
// settings file. That file also holds the user's own hooks, including kinds Beacon has no fields
// for: Claude Code's `http` hooks carry `url`, `headers` and `allowedEnvVars`, `prompt` and `agent`
// hooks carry `prompt` and `model`, and command hooks can carry `async` or `statusMessage`. A
// rewrite that decoded those into these structs and encoded them back dropped every field it did
// not model and added an empty `command`, which left a user's http guard hook in place but inert
// (#618). So an entry read from disk remembers its original JSON and is written back from it; see
// preserveUnmodelledJSON.
type settingsHookGroup struct {
	Matcher string            `json:"matcher,omitempty"`
	Hooks   []settingsHookRef `json:"hooks"`

	raw json.RawMessage
}

type settingsHookRef struct {
	Type    string `json:"type,omitempty"`
	Command string `json:"command"`
	Timeout int    `json:"timeout,omitempty"`
	// Shell names the interpreter the runtime should parse Command with, for runtimes that let a
	// hook say. Omitted by default, so the runtimes that do not expose the field are unaffected.
	//
	// It exists because Command is quoted for one specific shell -- see hookCommandQuote -- and a
	// runtime that picks a different one cannot run it at all. Saying which shell the command was
	// written for is strictly better than emitting a second quoting dialect and hoping the runtime
	// picks the matching one.
	Shell      string `json:"shell,omitempty"`
	ShowOutput *bool  `json:"show_output,omitempty"`

	raw json.RawMessage
}

// The alias types have the same fields and no methods, so the custom methods below can use the
// default encoding without recursing into themselves.
type settingsHookGroupFields settingsHookGroup
type settingsHookRefFields settingsHookRef

func (group *settingsHookGroup) UnmarshalJSON(data []byte) error {
	var fields settingsHookGroupFields
	if err := json.Unmarshal(data, &fields); err != nil {
		return err
	}
	*group = settingsHookGroup(fields)
	group.raw = bytes.Clone(data)
	return nil
}

func (group settingsHookGroup) MarshalJSON() ([]byte, error) {
	current := settingsHookGroupFields(group)
	if group.raw == nil {
		return json.Marshal(current)
	}
	var original settingsHookGroupFields
	if err := json.Unmarshal(group.raw, &original); err != nil {
		return nil, err
	}
	return preserveUnmodelledJSON(group.raw, original, current)
}

func (hook *settingsHookRef) UnmarshalJSON(data []byte) error {
	var fields settingsHookRefFields
	if err := json.Unmarshal(data, &fields); err != nil {
		return err
	}
	*hook = settingsHookRef(fields)
	hook.raw = bytes.Clone(data)
	return nil
}

func (hook settingsHookRef) MarshalJSON() ([]byte, error) {
	current := settingsHookRefFields(hook)
	if hook.raw == nil {
		return json.Marshal(current)
	}
	var original settingsHookRefFields
	if err := json.Unmarshal(hook.raw, &original); err != nil {
		return nil, err
	}
	return preserveUnmodelledJSON(hook.raw, original, current)
}

// preserveUnmodelledJSON re-encodes an object Beacon read from disk. raw is the object as it was
// read, original is raw decoded into Beacon's struct, and current is that struct now. Every field
// whose encoding is unchanged keeps raw's spelling, including whether it was present at all, so an
// object nobody edited comes back byte for byte and one that was edited keeps every field Beacon
// does not model.
func preserveUnmodelledJSON(raw json.RawMessage, original, current any) ([]byte, error) {
	before, err := jsonObjectFields(original)
	if err != nil {
		return nil, err
	}
	after, err := jsonObjectFields(current)
	if err != nil {
		return nil, err
	}
	var out map[string]json.RawMessage
	edited := false
	for _, fields := range []map[string]json.RawMessage{before, after} {
		for key := range fields {
			was, hadBefore := before[key]
			now, hasAfter := after[key]
			if hadBefore == hasAfter && bytes.Equal(was, now) {
				continue
			}
			if !edited {
				if err := json.Unmarshal(raw, &out); err != nil {
					return nil, err
				}
				edited = true
			}
			if hasAfter {
				out[key] = now
			} else {
				delete(out, key)
			}
		}
	}
	if !edited {
		return raw, nil
	}
	return json.Marshal(out)
}

func jsonObjectFields(value any) (map[string]json.RawMessage, error) {
	data, err := json.Marshal(value)
	if err != nil {
		return nil, err
	}
	var fields map[string]json.RawMessage
	if err := json.Unmarshal(data, &fields); err != nil {
		return nil, err
	}
	return fields, nil
}

type settingsHooksFile struct {
	values map[string]json.RawMessage
	hooks  map[string][]settingsHookGroup
}

func readSettingsHooks(path string) (settingsHooksFile, error) {
	settings := settingsHooksFile{
		values: map[string]json.RawMessage{},
		hooks:  map[string][]settingsHookGroup{},
	}
	data, err := os.ReadFile(path)
	if err == nil {
		if err := json.Unmarshal(data, &settings.values); err != nil {
			return settingsHooksFile{}, err
		}
		if rawHooks, ok := settings.values["hooks"]; ok {
			if err := json.Unmarshal(rawHooks, &settings.hooks); err != nil {
				return settingsHooksFile{}, err
			}
		}
	} else if !os.IsNotExist(err) {
		return settingsHooksFile{}, err
	}
	if settings.hooks == nil {
		settings.hooks = map[string][]settingsHookGroup{}
	}
	return settings, nil
}

func (settings settingsHooksFile) marshal() ([]byte, error) {
	out := make(map[string]json.RawMessage, len(settings.values)+1)
	for key, value := range settings.values {
		if key != "hooks" {
			out[key] = value
		}
	}
	if len(settings.hooks) > 0 {
		data, err := json.Marshal(settings.hooks)
		if err != nil {
			return nil, err
		}
		out["hooks"] = data
	}
	return json.MarshalIndent(out, "", "  ")
}

func installSettingsEndpointHooks(path, platform string, endpointHooks map[string]settingsHookGroup) error {
	groups := make(map[string][]settingsHookGroup, len(endpointHooks))
	for eventName, group := range endpointHooks {
		groups[eventName] = []settingsHookGroup{group}
	}
	return installSettingsEndpointHookGroups(path, platform, groups)
}

// installSettingsEndpointHookGroups is installSettingsEndpointHooks for events that carry more
// than one Beacon group, such as two PreToolUse groups with different matchers. Beacon's existing
// groups are removed once, up front, and every group for an event is appended after the user's
// own, in the order given.
func installSettingsEndpointHookGroups(path, platform string, endpointHooks map[string][]settingsHookGroup) error {
	settings, err := readSettingsHooks(path)
	if err != nil {
		return err
	}
	removeSettingsEndpointHooksFromLoaded(&settings, platform)
	for eventName, groups := range endpointHooks {
		if len(groups) == 0 {
			continue
		}
		merged := mergeSettingsEndpointHook(settings.hooks[eventName], groups[0], platform)
		settings.hooks[eventName] = append(merged, groups[1:]...)
	}
	data, err := settings.marshal()
	if err != nil {
		return err
	}
	return os.WriteFile(path, data, 0600)
}

func removeSettingsEndpointHooksFromLoaded(settings *settingsHooksFile, platform string) bool {
	if settings == nil {
		return false
	}
	changed := false
	for eventName, groups := range settings.hooks {
		eventChanged := false
		filtered := groups[:0]
		for _, group := range groups {
			withoutEndpointHooks, groupChanged := filterSettingsEndpointHooks(group, platform)
			if groupChanged {
				eventChanged = true
			}
			// Drop a group only when removing Beacon's hooks emptied it. A group the user left
			// empty is theirs, and is kept like any other entry Beacon did not write.
			if groupChanged && len(withoutEndpointHooks.Hooks) == 0 {
				continue
			}
			filtered = append(filtered, withoutEndpointHooks)
		}
		if !eventChanged {
			continue
		}
		changed = true
		if len(filtered) == 0 {
			delete(settings.hooks, eventName)
		} else {
			settings.hooks[eventName] = filtered
		}
	}
	return changed
}

func mergeSettingsEndpointHook(existing []settingsHookGroup, group settingsHookGroup, platform string) []settingsHookGroup {
	out := make([]settingsHookGroup, 0, len(existing)+1)
	for _, item := range existing {
		filtered, changed := filterSettingsEndpointHooks(item, platform)
		if !changed || len(filtered.Hooks) > 0 {
			out = append(out, item)
			if changed {
				out[len(out)-1] = filtered
			}
		}
	}
	return append(out, group)
}

func removeSettingsEndpointHooks(path, platform string) (bool, error) {
	settings, err := readSettingsHooks(path)
	if err != nil {
		if os.IsNotExist(err) {
			return false, nil
		}
		return false, err
	}
	if !removeSettingsEndpointHooksFromLoaded(&settings, platform) {
		return false, nil
	}
	out, err := settings.marshal()
	if err != nil {
		return false, err
	}
	return true, os.WriteFile(path, out, 0600)
}

func filterSettingsEndpointHooks(group settingsHookGroup, platform string) (settingsHookGroup, bool) {
	filtered := group
	filtered.Hooks = group.Hooks[:0]
	changed := false
	for _, hook := range group.Hooks {
		if isSettingsEndpointHookCommand(hook.Command, platform) {
			changed = true
			continue
		}
		filtered.Hooks = append(filtered.Hooks, hook)
	}
	return filtered, changed
}

func isSettingsEndpointHookGroup(group settingsHookGroup, platform string) bool {
	for _, hook := range group.Hooks {
		if isSettingsEndpointHookCommand(hook.Command, platform) {
			return true
		}
	}
	return false
}

func isSettingsEndpointHookCommand(command, platform string) bool {
	if platform != "" && !hookcmd.HasPlatform(command, platform) {
		return false
	}
	return hookcmd.IsEndpointHook(command, platform)
}

func isSettingsEndpointInstalledAt(path, platform string) bool {
	settings, err := readSettingsHooks(path)
	if err != nil {
		return false
	}
	for _, groups := range settings.hooks {
		for _, group := range groups {
			if isSettingsEndpointHookGroup(group, platform) {
				return true
			}
		}
	}
	return false
}