feat: rules evaluation, redesign ui

Author: johnste

apps/finicky/src/browser/browsers.json

@@ -80,7 +80,7 @@
   {
     "config_dir_relative": "",
     "id": "com.apple.Safari",
-    "type": "",
+    "type": "Safari",
     "app_name": "Safari"
   },
   {

apps/finicky/src/config/configfiles.go

@@ -369,7 +369,10 @@ func (cfw *ConfigFileWatcher) handleConfigFileEvent(event fsnotify.Event) error
 	}
 	notify := cfw.configChangeNotify
 	cfw.debounceTimer = time.AfterFunc(500*time.Millisecond, func() {
-		notify <- struct{}{}
+		select {
+		case notify <- struct{}{}:
+		default: // drop if a notification is already pending
+		}
 	})
 	cfw.debounceMu.Unlock()
 	return nil

apps/finicky/src/main.go

@@ -144,7 +144,7 @@ func main() {
 		slog.Debug("Rules updated", "count", len(rf.Rules))
 		resolver.SetCachedRules(rf)
 		if vm == nil || !vm.IsJSConfig() {
-			if rf.DefaultBrowser == "" && len(rf.Rules) == 0 {
+			if rf.DefaultBrowser == "" && len(rf.Rules) == 0 && rf.Options == nil {
 				vm = nil
 				return
 			}
@@ -417,6 +417,14 @@ func setupVM(cfw *config.ConfigFileWatcher, namespace string) (*config.VM, error
 		}
 	}
 
+	// Always seed the cached rules from disk so JSON rules are applied
+	// immediately on startup, even when a JS config is also present.
+	if rf, rulesErr := rules.Load(); rulesErr != nil {
+		slog.Warn("Failed to pre-load rules cache", "error", rulesErr)
+	} else {
+		resolver.SetCachedRules(rf)
+	}
+
 	var newVM *config.VM
 
 	if currentBundlePath != "" {

apps/finicky/src/resolver/resolver_test.go

@@ -95,8 +95,8 @@ func TestResolveURL_JSONRulesOnly(t *testing.T) {
 	rf := rules.RulesFile{
 		DefaultBrowser: "Firefox",
 		Rules: []rules.Rule{
-			{Match: "*github.com/*", Browser: "Google Chrome"},
-			{Match: "https://linear.app/*", Browser: "Safari"},
+			{Match: []string{"*github.com/*"}, Browser: "Google Chrome"},
+			{Match: []string{"https://linear.app/*"}, Browser: "Safari"},
 		},
 	}
 	vm := rulesVM(t, rf)
@@ -126,7 +126,7 @@ func TestResolveURL_JSONRulesWithProfile(t *testing.T) {
 	rf := rules.RulesFile{
 		DefaultBrowser: "Safari",
 		Rules: []rules.Rule{
-			{Match: "*github.com/*", Browser: "Google Chrome", Profile: "Work"},
+			{Match: []string{"*github.com/*"}, Browser: "Google Chrome", Profile: "Work"},
 		},
 	}
 	vm := rulesVM(t, rf)
@@ -176,6 +176,47 @@ func TestResolveURL_MergedJSAndJSON(t *testing.T) {
 	}
 }
 
+// TestResolveURL_MergedJSAndJSON_WithCachedRules verifies that JSON rules are
+// applied when a JS config is present and cached rules have been seeded
+// (simulating the fix for the startup bug where SetCachedRules was not called
+// when a JS config existed).
+func TestResolveURL_MergedJSAndJSON_WithCachedRules(t *testing.T) {
+	jsConfig := jsVM(t, `({
+		defaultBrowser: "Safari",
+		handlers: [
+			{ match: "*github.com/*", browser: "Firefox" }
+		]
+	})`)
+
+	SetCachedRules(rules.RulesFile{
+		DefaultBrowser: "Safari",
+		Rules: []rules.Rule{
+			{Match: []string{"linear.app/*"}, Browser: "Google Chrome"},
+		},
+	})
+	t.Cleanup(func() { SetCachedRules(rules.RulesFile{}) })
+
+	tests := []struct {
+		url     string
+		browser string
+	}{
+		{"https://github.com/foo", "Firefox"},          // JS handler wins
+		{"https://linear.app/team/issue/1", "Google Chrome"}, // JSON rule applies
+		{"https://example.com", "Safari"},              // JS default
+	}
+	for _, tt := range tests {
+		t.Run(tt.url, func(t *testing.T) {
+			result, err := ResolveURL(jsConfig, tt.url, nil, false)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if result.Name != tt.browser {
+				t.Errorf("got %q, want %q", result.Name, tt.browser)
+			}
+		})
+	}
+}
+
 func TestResolveURL_JSConfigFunctionHandler(t *testing.T) {
 	vm := jsVM(t, `({
 		defaultBrowser: "Safari",

apps/finicky/src/rules/rules.go

@@ -8,9 +8,48 @@ import (
 )
 
 type Rule struct {
-	Match   string `json:"match"`
-	Browser string `json:"browser"`
-	Profile string `json:"profile,omitempty"`
+	Match   []string `json:"match"`
+	Browser string   `json:"browser"`
+	Profile string   `json:"profile,omitempty"`
+}
+
+// UnmarshalJSON accepts both a single string and an array for the match field.
+func (r *Rule) UnmarshalJSON(data []byte) error {
+	var raw struct {
+		Match   json.RawMessage `json:"match"`
+		Browser string          `json:"browser"`
+		Profile string          `json:"profile,omitempty"`
+	}
+	if err := json.Unmarshal(data, &raw); err != nil {
+		return err
+	}
+	r.Browser = raw.Browser
+	r.Profile = raw.Profile
+	if raw.Match != nil {
+		var s string
+		if err := json.Unmarshal(raw.Match, &s); err == nil {
+			r.Match = []string{s}
+			return nil
+		}
+		return json.Unmarshal(raw.Match, &r.Match)
+	}
+	return nil
+}
+
+// MarshalJSON serializes match as a plain string when there is only one entry.
+func (r Rule) MarshalJSON() ([]byte, error) {
+	type RuleAlias struct {
+		Match   interface{} `json:"match"`
+		Browser string      `json:"browser"`
+		Profile string      `json:"profile,omitempty"`
+	}
+	var match interface{}
+	if len(r.Match) == 1 {
+		match = r.Match[0]
+	} else {
+		match = r.Match
+	}
+	return json.Marshal(RuleAlias{Match: match, Browser: r.Browser, Profile: r.Profile})
 }
 
 type Options struct {
@@ -106,17 +145,30 @@ func SaveToPath(rf RulesFile, path string) error {
 func ToJSHandlers(rules []Rule) []map[string]interface{} {
 	handlers := make([]map[string]interface{}, 0, len(rules))
 	for _, r := range rules {
-		if r.Match == "" || r.Browser == "" {
+		// Filter out empty patterns
+		matches := make([]string, 0, len(r.Match))
+		for _, m := range r.Match {
+			if m != "" {
+				matches = append(matches, m)
+			}
+		}
+		if len(matches) == 0 || r.Browser == "" {
 			continue
 		}
+		var matchVal interface{}
+		if len(matches) == 1 {
+			matchVal = matches[0]
+		} else {
+			matchVal = matches
+		}
 		var browser interface{}
 		if r.Profile != "" {
 			browser = map[string]interface{}{"name": r.Browser, "profile": r.Profile}
 		} else {
 			browser = r.Browser
 		}
 		handlers = append(handlers, map[string]interface{}{
-			"match":   r.Match,
+			"match":   matchVal,
 			"browser": browser,
 		})
 	}

apps/finicky/src/rules/rules_test.go

@@ -3,6 +3,7 @@ package rules_test
 import (
 	"os"
 	"path/filepath"
+	"reflect"
 	"strings"
 	"testing"
 
@@ -20,9 +21,9 @@ func TestToJSHandlers_Empty(t *testing.T) {
 
 func TestToJSHandlers_SkipsIncompleteRules(t *testing.T) {
 	rules := []Rule{
-		{Match: "", Browser: "Firefox"},  // no match
-		{Match: "example.com", Browser: ""}, // no browser
-		{Match: "example.com", Browser: "Safari"}, // valid
+		{Match: []string{""}, Browser: "Firefox"},         // no match
+		{Match: []string{"example.com"}, Browser: ""},     // no browser
+		{Match: []string{"example.com"}, Browser: "Safari"}, // valid
 	}
 	result := ToJSHandlers(rules)
 	if len(result) != 1 {
@@ -32,7 +33,7 @@ func TestToJSHandlers_SkipsIncompleteRules(t *testing.T) {
 
 func TestToJSHandlers_StringBrowser(t *testing.T) {
 	rules := []Rule{
-		{Match: "*github.com/*", Browser: "Firefox"},
+		{Match: []string{"*github.com/*"}, Browser: "Firefox"},
 	}
 	result := ToJSHandlers(rules)
 	if len(result) != 1 {
@@ -49,7 +50,7 @@ func TestToJSHandlers_StringBrowser(t *testing.T) {
 
 func TestToJSHandlers_WithProfile(t *testing.T) {
 	rules := []Rule{
-		{Match: "*github.com/*", Browser: "Google Chrome", Profile: "Work"},
+		{Match: []string{"*github.com/*"}, Browser: "Google Chrome", Profile: "Work"},
 	}
 	result := ToJSHandlers(rules)
 	if len(result) != 1 {
@@ -69,9 +70,9 @@ func TestToJSHandlers_WithProfile(t *testing.T) {
 
 func TestToJSHandlers_MultipleRules(t *testing.T) {
 	rules := []Rule{
-		{Match: "*github.com/*", Browser: "Firefox"},
-		{Match: "https://linear.app/*", Browser: "Google Chrome", Profile: "Work"},
-		{Match: "example.com", Browser: "Safari"},
+		{Match: []string{"*github.com/*"}, Browser: "Firefox"},
+		{Match: []string{"https://linear.app/*"}, Browser: "Google Chrome", Profile: "Work"},
+		{Match: []string{"example.com"}, Browser: "Safari"},
 	}
 	result := ToJSHandlers(rules)
 	if len(result) != 3 {
@@ -86,7 +87,7 @@ func TestToJSHandlers_MultipleRules(t *testing.T) {
 // ---- ToJSConfigScript ----
 
 func TestToJSConfigScript_DefaultBrowserFallback(t *testing.T) {
-	rf := RulesFile{Rules: []Rule{{Match: "example.com", Browser: "Firefox"}}}
+	rf := RulesFile{Rules: []Rule{{Match: []string{"example.com"}, Browser: "Firefox"}}}
 	script, err := ToJSConfigScript(rf, "finickyConfig")
 	if err != nil {
 		t.Fatal(err)
@@ -133,8 +134,8 @@ func TestLoadSave_RoundTrip(t *testing.T) {
 		DefaultBrowser: "Firefox",
 		DefaultProfile: "Work",
 		Rules: []Rule{
-			{Match: "*github.com/*", Browser: "Google Chrome", Profile: "Personal"},
-			{Match: "https://linear.app/*", Browser: "Safari"},
+			{Match: []string{"*github.com/*"}, Browser: "Google Chrome", Profile: "Personal"},
+			{Match: []string{"https://linear.app/*"}, Browser: "Safari"},
 		},
 	}
 
@@ -158,7 +159,7 @@ func TestLoadSave_RoundTrip(t *testing.T) {
 	}
 	for i, r := range original.Rules {
 		got := loaded.Rules[i]
-		if got.Match != r.Match || got.Browser != r.Browser || got.Profile != r.Profile {
+		if !reflect.DeepEqual(got.Match, r.Match) || got.Browser != r.Browser || got.Profile != r.Profile {
 			t.Errorf("Rule[%d]: got %+v, want %+v", i, got, r)
 		}
 	}

apps/finicky/src/version/version.go

@@ -236,6 +236,16 @@ func checkForUpdates() (releaseInfo *ReleaseInfo) {
 
 // CheckForUpdatesIfEnabled checks if updates should be performed based on VM configuration
 func CheckForUpdatesIfEnabled(vm *goja.Runtime) (releaseInfo *ReleaseInfo, updateCheckEnabled bool, err error) {
+	if mockVersion := os.Getenv("FINICKY_MOCK_UPDATE"); mockVersion != "" {
+		slog.Info("FINICKY_MOCK_UPDATE set, returning mock update", "version", mockVersion)
+		mockTag := strings.TrimPrefix(mockVersion, "v")
+		return &ReleaseInfo{
+			HasUpdate:     true,
+			LatestVersion: mockVersion,
+			DownloadUrl:   fmt.Sprintf("https://github.com/johnste/finicky/releases/tag/v%s", mockTag),
+			ReleaseUrl:    fmt.Sprintf("https://github.com/johnste/finicky/releases/tag/v%s", mockTag),
+		}, true, nil
+	}
 
 	if vm == nil {
 		// Check for updates if we don't have a VM