feat: add Safari browser support with history extraction (#564)

* feat: add Safari browser support with history extraction
* fix: use correlated subquery to ensure title matches latest visit

Author: moonD4rk

browser/browser.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/moond4rk/hackbrowserdata/browser/chromium"
 	"github.com/moond4rk/hackbrowserdata/browser/firefox"
+	"github.com/moond4rk/hackbrowserdata/browser/safari"
 	"github.com/moond4rk/hackbrowserdata/crypto/keyretriever"
 	"github.com/moond4rk/hackbrowserdata/log"
 	"github.com/moond4rk/hackbrowserdata/types"
@@ -150,6 +151,17 @@ func newBrowsers(cfg types.BrowserConfig) ([]Browser, error) {
 		}
 		return result, nil
 
+	case types.Safari:
+		found, err := safari.NewBrowsers(cfg)
+		if err != nil {
+			return nil, err
+		}
+		result := make([]Browser, len(found))
+		for i, b := range found {
+			result[i] = b
+		}
+		return result, nil
+
 	default:
 		return nil, fmt.Errorf("unknown browser kind: %d", cfg.Kind)
 	}

browser/browser_darwin.go

@@ -91,5 +91,11 @@ func platformBrowsers() []types.BrowserConfig {
 			Kind:        types.Firefox,
 			UserDataDir: homeDir + "/Library/Application Support/Firefox/Profiles",
 		},
+		{
+			Key:         "safari",
+			Name:        safariName,
+			Kind:        types.Safari,
+			UserDataDir: homeDir + "/Library/Safari",
+		},
 	}
 }

browser/browser_test.go

@@ -349,6 +349,9 @@ func TestNewBrowsersDispatch(t *testing.T) {
 	firefoxDir := t.TempDir()
 	mkFile(t, firefoxDir, "abc.default", "places.sqlite")
 
+	safariDir := t.TempDir()
+	mkFile(t, safariDir, "History.db")
+
 	emptyDir := t.TempDir()
 
 	tests := []struct {
@@ -373,6 +376,13 @@ func TestNewBrowsersDispatch(t *testing.T) {
 			wantName:    "Firefox",
 			wantProfile: "abc.default",
 		},
+		{
+			name:        "safari dispatch",
+			cfg:         types.BrowserConfig{Key: "safari", Name: "Safari", Kind: types.Safari, UserDataDir: safariDir},
+			wantLen:     1,
+			wantName:    "Safari",
+			wantProfile: "default",
+		},
 		{
 			name:    "unknown kind returns error",
 			cfg:     types.BrowserConfig{Key: "unknown", Name: "Unknown", Kind: types.BrowserKind(99)},

browser/consts.go

@@ -26,4 +26,5 @@ const (
 	sogouName      = "Sogou"
 	arcName        = "Arc"
 	duckduckgoName = "DuckDuckGo"
+	safariName     = "Safari"
 )

browser/safari/extract_history.go

@@ -0,0 +1,56 @@
+package safari
+
+import (
+	"database/sql"
+	"sort"
+
+	"github.com/moond4rk/hackbrowserdata/types"
+	"github.com/moond4rk/hackbrowserdata/utils/sqliteutil"
+)
+
+const (
+	// safariHistoryQuery joins each history item to its latest visit so
+	// title and visit_time come from the same history_visits row.
+	safariHistoryQuery = `SELECT hi.url, COALESCE(hv.title, ''), hi.visit_count,
+		COALESCE(hv.visit_time, 0)
+		FROM history_items hi
+		LEFT JOIN history_visits hv ON hv.id = (
+			SELECT hv2.id FROM history_visits hv2
+			WHERE hv2.history_item = hi.id
+			ORDER BY hv2.visit_time DESC LIMIT 1
+		)`
+
+	safariCountHistoryQuery = `SELECT COUNT(*) FROM history_items`
+)
+
+func extractHistories(path string) ([]types.HistoryEntry, error) {
+	histories, err := sqliteutil.QueryRows(path, true, safariHistoryQuery,
+		func(rows *sql.Rows) (types.HistoryEntry, error) {
+			var (
+				url, title string
+				visitCount int
+				visitTime  float64
+			)
+			if err := rows.Scan(&url, &title, &visitCount, &visitTime); err != nil {
+				return types.HistoryEntry{}, err
+			}
+			return types.HistoryEntry{
+				URL:        url,
+				Title:      title,
+				VisitCount: visitCount,
+				LastVisit:  coredataTimestamp(visitTime),
+			}, nil
+		})
+	if err != nil {
+		return nil, err
+	}
+
+	sort.Slice(histories, func(i, j int) bool {
+		return histories[i].VisitCount > histories[j].VisitCount
+	})
+	return histories, nil
+}
+
+func countHistories(path string) (int, error) {
+	return sqliteutil.CountRows(path, true, safariCountHistoryQuery)
+}

browser/safari/extract_history_test.go

@@ -0,0 +1,105 @@
+package safari
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func setupSafariHistoryDB(t *testing.T) string {
+	t.Helper()
+	return createTestDB(t, "History.db",
+		[]string{safariHistoryItemsSchema, safariHistoryVisitsSchema},
+		insertHistoryItem(1, "https://github.com", "github.com", 100),
+		insertHistoryItem(2, "https://go.dev", "go.dev", 50),
+		insertHistoryItem(3, "https://example.com", "example.com", 200),
+		// Item 1 has two visits — extractHistories must deduplicate.
+		insertHistoryVisit(1, 1, 704067600.0, "GitHub"),
+		insertHistoryVisit(2, 1, 705067600.0, "GitHub - Latest"),
+		insertHistoryVisit(3, 2, 703067600.0, "The Go Programming Language"),
+		insertHistoryVisit(4, 3, 700067600.0, "Example Domain"),
+	)
+}
+
+func TestExtractHistories(t *testing.T) {
+	path := setupSafariHistoryDB(t)
+
+	got, err := extractHistories(path)
+	require.NoError(t, err)
+	require.Len(t, got, 3)
+
+	// Sorted by visit count descending (most visited first).
+	assert.Equal(t, 200, got[0].VisitCount)
+	assert.Equal(t, 100, got[1].VisitCount)
+	assert.Equal(t, 50, got[2].VisitCount)
+
+	// Verify field mapping.
+	assert.Equal(t, "https://example.com", got[0].URL)
+	assert.Equal(t, "https://github.com", got[1].URL)
+	assert.Equal(t, "https://go.dev", got[2].URL)
+	assert.False(t, got[0].LastVisit.IsZero())
+}
+
+func TestExtractHistories_Dedup(t *testing.T) {
+	path := setupSafariHistoryDB(t)
+
+	got, err := extractHistories(path)
+	require.NoError(t, err)
+	// 3 history_items, not 4 visits.
+	require.Len(t, got, 3)
+
+	// GitHub (item 1) should have the later visit_time and its title.
+	for _, h := range got {
+		if h.URL == "https://github.com" {
+			// 705067600 + 978307200 = 1683374800 (unix)
+			assert.Equal(t, int64(1683374800), h.LastVisit.Unix())
+			// Title must come from the latest visit row, not an arbitrary one.
+			assert.Equal(t, "GitHub - Latest", h.Title)
+			return
+		}
+	}
+	t.Fatal("expected https://github.com in results")
+}
+
+func TestCountHistories(t *testing.T) {
+	path := setupSafariHistoryDB(t)
+
+	count, err := countHistories(path)
+	require.NoError(t, err)
+	assert.Equal(t, 3, count)
+}
+
+func TestCountHistories_Empty(t *testing.T) {
+	path := createTestDB(t, "History.db",
+		[]string{safariHistoryItemsSchema, safariHistoryVisitsSchema})
+
+	count, err := countHistories(path)
+	require.NoError(t, err)
+	assert.Equal(t, 0, count)
+}
+
+func TestExtractHistories_NullTitle(t *testing.T) {
+	path := createTestDB(t, "History.db",
+		[]string{safariHistoryItemsSchema, safariHistoryVisitsSchema},
+		insertHistoryItem(1, "https://null.test", "null.test", 1),
+		// Visit with NULL title — COALESCE should return empty string.
+		`INSERT INTO history_visits (id, history_item, visit_time) VALUES (1, 1, 700000000.0)`,
+	)
+
+	got, err := extractHistories(path)
+	require.NoError(t, err)
+	require.Len(t, got, 1)
+	assert.Equal(t, "https://null.test", got[0].URL)
+	assert.Empty(t, got[0].Title)
+}
+
+func TestCoredataTimestamp(t *testing.T) {
+	// 0 Core Data epoch = 2001-01-01 00:00:00 UTC = Unix 978307200
+	ts := coredataTimestamp(0)
+	assert.Equal(t, int64(978307200), ts.Unix())
+
+	// Known value: 700000000 Core Data = 1678307200 Unix
+	ts2 := coredataTimestamp(700000000)
+	assert.Equal(t, int64(1678307200), ts2.Unix())
+}