feat: add Safari bookmark and download extraction from plist (#567)

* feat: add Safari bookmark and download extraction from plist files
* test: add nested folder test for bookmark tree traversal
Part of #565

Author: moonD4rk

browser/safari/extract_bookmark.go

@@ -0,0 +1,84 @@
+package safari
+
+import (
+	"fmt"
+	"os"
+	"time"
+
+	"github.com/moond4rk/plist"
+
+	"github.com/moond4rk/hackbrowserdata/types"
+)
+
+// safariBookmark mirrors the plist structure of Safari's Bookmarks.plist.
+type safariBookmark struct {
+	Type          string           `plist:"WebBookmarkType"`
+	Title         string           `plist:"Title"`
+	URLString     string           `plist:"URLString"`
+	URIDictionary uriDictionary    `plist:"URIDictionary"`
+	Children      []safariBookmark `plist:"Children"`
+}
+
+type uriDictionary struct {
+	Title string `plist:"title"`
+}
+
+const (
+	bookmarkTypeLeaf = "WebBookmarkTypeLeaf"
+	bookmarkTypeList = "WebBookmarkTypeList"
+)
+
+func extractBookmarks(path string) ([]types.BookmarkEntry, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return nil, fmt.Errorf("open bookmarks: %w", err)
+	}
+	defer f.Close()
+
+	var root safariBookmark
+	if err := plist.NewDecoder(f).Decode(&root); err != nil {
+		return nil, fmt.Errorf("decode bookmarks: %w", err)
+	}
+
+	var bookmarks []types.BookmarkEntry
+	walkBookmarks(root.Children, "", &bookmarks)
+	return bookmarks, nil
+}
+
+// walkBookmarks recursively traverses the bookmark tree, collecting leaf entries.
+func walkBookmarks(nodes []safariBookmark, folder string, out *[]types.BookmarkEntry) {
+	for i, node := range nodes {
+		switch node.Type {
+		case bookmarkTypeLeaf:
+			title := node.URIDictionary.Title
+			if title == "" {
+				title = node.Title
+			}
+			if node.URLString == "" {
+				continue
+			}
+			*out = append(*out, types.BookmarkEntry{
+				ID:        int64(i),
+				Name:      title,
+				URL:       node.URLString,
+				Folder:    folder,
+				Type:      "bookmark",
+				CreatedAt: time.Time{},
+			})
+		case bookmarkTypeList:
+			name := node.Title
+			if name == "com.apple.ReadingList" {
+				name = "ReadingList"
+			}
+			walkBookmarks(node.Children, name, out)
+		}
+	}
+}
+
+func countBookmarks(path string) (int, error) {
+	bookmarks, err := extractBookmarks(path)
+	if err != nil {
+		return 0, err
+	}
+	return len(bookmarks), nil
+}

browser/safari/extract_bookmark_test.go

@@ -0,0 +1,179 @@
+package safari
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/moond4rk/plist"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func buildTestBookmarksPlist(t *testing.T, root safariBookmark) string {
+	t.Helper()
+	path := filepath.Join(t.TempDir(), "Bookmarks.plist")
+	f, err := os.Create(path)
+	require.NoError(t, err)
+	defer f.Close()
+	require.NoError(t, plist.NewBinaryEncoder(f).Encode(root))
+	return path
+}
+
+func TestExtractBookmarks(t *testing.T) {
+	root := safariBookmark{
+		Type: bookmarkTypeList,
+		Children: []safariBookmark{
+			{
+				Type:  bookmarkTypeList,
+				Title: "BookmarksBar",
+				Children: []safariBookmark{
+					{
+						Type:          bookmarkTypeLeaf,
+						URLString:     "https://github.com",
+						URIDictionary: uriDictionary{Title: "GitHub"},
+					},
+					{
+						Type:          bookmarkTypeLeaf,
+						URLString:     "https://go.dev",
+						URIDictionary: uriDictionary{Title: "Go"},
+					},
+				},
+			},
+			{
+				Type:  bookmarkTypeList,
+				Title: "BookmarksMenu",
+				Children: []safariBookmark{
+					{
+						Type:          bookmarkTypeLeaf,
+						URLString:     "https://example.com",
+						URIDictionary: uriDictionary{Title: "Example"},
+					},
+				},
+			},
+		},
+	}
+
+	path := buildTestBookmarksPlist(t, root)
+	bookmarks, err := extractBookmarks(path)
+	require.NoError(t, err)
+	require.Len(t, bookmarks, 3)
+
+	// Verify folder assignment
+	assert.Equal(t, "GitHub", bookmarks[0].Name)
+	assert.Equal(t, "https://github.com", bookmarks[0].URL)
+	assert.Equal(t, "BookmarksBar", bookmarks[0].Folder)
+
+	assert.Equal(t, "Go", bookmarks[1].Name)
+	assert.Equal(t, "BookmarksBar", bookmarks[1].Folder)
+
+	assert.Equal(t, "Example", bookmarks[2].Name)
+	assert.Equal(t, "BookmarksMenu", bookmarks[2].Folder)
+}
+
+func TestExtractBookmarks_ReadingList(t *testing.T) {
+	root := safariBookmark{
+		Type: bookmarkTypeList,
+		Children: []safariBookmark{
+			{
+				Type:  bookmarkTypeList,
+				Title: "com.apple.ReadingList",
+				Children: []safariBookmark{
+					{
+						Type:          bookmarkTypeLeaf,
+						URLString:     "https://blog.example.com/post",
+						URIDictionary: uriDictionary{Title: "Blog Post"},
+					},
+				},
+			},
+		},
+	}
+
+	path := buildTestBookmarksPlist(t, root)
+	bookmarks, err := extractBookmarks(path)
+	require.NoError(t, err)
+	require.Len(t, bookmarks, 1)
+	assert.Equal(t, "ReadingList", bookmarks[0].Folder)
+}
+
+func TestExtractBookmarks_SkipsEmptyURL(t *testing.T) {
+	root := safariBookmark{
+		Type: bookmarkTypeList,
+		Children: []safariBookmark{
+			{
+				Type:          bookmarkTypeLeaf,
+				URLString:     "", // no URL, should be skipped
+				URIDictionary: uriDictionary{Title: "Empty"},
+			},
+			{
+				Type:          bookmarkTypeLeaf,
+				URLString:     "https://valid.com",
+				URIDictionary: uriDictionary{Title: "Valid"},
+			},
+		},
+	}
+
+	path := buildTestBookmarksPlist(t, root)
+	bookmarks, err := extractBookmarks(path)
+	require.NoError(t, err)
+	require.Len(t, bookmarks, 1)
+	assert.Equal(t, "Valid", bookmarks[0].Name)
+}
+
+func TestExtractBookmarks_NestedFolders(t *testing.T) {
+	root := safariBookmark{
+		Type: bookmarkTypeList,
+		Children: []safariBookmark{
+			{
+				Type:  bookmarkTypeList,
+				Title: "Work",
+				Children: []safariBookmark{
+					{
+						Type:  bookmarkTypeList,
+						Title: "Projects",
+						Children: []safariBookmark{
+							{Type: bookmarkTypeLeaf, URLString: "https://deep.com", URIDictionary: uriDictionary{Title: "Deep"}},
+						},
+					},
+					{Type: bookmarkTypeLeaf, URLString: "https://shallow.com", URIDictionary: uriDictionary{Title: "Shallow"}},
+				},
+			},
+		},
+	}
+
+	path := buildTestBookmarksPlist(t, root)
+	bookmarks, err := extractBookmarks(path)
+	require.NoError(t, err)
+	require.Len(t, bookmarks, 2)
+
+	// Nested leaf gets the immediate parent folder name
+	assert.Equal(t, "Deep", bookmarks[0].Name)
+	assert.Equal(t, "Projects", bookmarks[0].Folder)
+
+	assert.Equal(t, "Shallow", bookmarks[1].Name)
+	assert.Equal(t, "Work", bookmarks[1].Folder)
+}
+
+func TestCountBookmarks(t *testing.T) {
+	root := safariBookmark{
+		Type: bookmarkTypeList,
+		Children: []safariBookmark{
+			{Type: bookmarkTypeLeaf, URLString: "https://a.com", URIDictionary: uriDictionary{Title: "A"}},
+			{Type: bookmarkTypeLeaf, URLString: "https://b.com", URIDictionary: uriDictionary{Title: "B"}},
+		},
+	}
+
+	path := buildTestBookmarksPlist(t, root)
+	count, err := countBookmarks(path)
+	require.NoError(t, err)
+	assert.Equal(t, 2, count)
+}
+
+func TestExtractBookmarks_Empty(t *testing.T) {
+	root := safariBookmark{Type: bookmarkTypeList}
+	path := buildTestBookmarksPlist(t, root)
+
+	bookmarks, err := extractBookmarks(path)
+	require.NoError(t, err)
+	assert.Empty(t, bookmarks)
+}

browser/safari/extract_download.go

@@ -0,0 +1,54 @@
+package safari
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/moond4rk/plist"
+
+	"github.com/moond4rk/hackbrowserdata/types"
+)
+
+// safariDownloads mirrors the plist structure of Safari's Downloads.plist.
+type safariDownloads struct {
+	DownloadHistory []safariDownloadEntry `plist:"DownloadHistory"`
+}
+
+type safariDownloadEntry struct {
+	URL                string  `plist:"DownloadEntryURL"`
+	Path               string  `plist:"DownloadEntryPath"`
+	TotalBytes         float64 `plist:"DownloadEntryProgressTotalToLoad"`
+	RemoveWhenDone     bool    `plist:"DownloadEntryRemoveWhenDoneKey"`
+	DownloadIdentifier string  `plist:"DownloadEntryIdentifier"`
+}
+
+func extractDownloads(path string) ([]types.DownloadEntry, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return nil, fmt.Errorf("open downloads: %w", err)
+	}
+	defer f.Close()
+
+	var dl safariDownloads
+	if err := plist.NewDecoder(f).Decode(&dl); err != nil {
+		return nil, fmt.Errorf("decode downloads: %w", err)
+	}
+
+	var downloads []types.DownloadEntry
+	for _, d := range dl.DownloadHistory {
+		downloads = append(downloads, types.DownloadEntry{
+			URL:        d.URL,
+			TargetPath: d.Path,
+			TotalBytes: int64(d.TotalBytes),
+		})
+	}
+	return downloads, nil
+}
+
+func countDownloads(path string) (int, error) {
+	downloads, err := extractDownloads(path)
+	if err != nil {
+		return 0, err
+	}
+	return len(downloads), nil
+}

browser/safari/extract_download_test.go

@@ -0,0 +1,74 @@
+package safari
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/moond4rk/plist"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func buildTestDownloadsPlist(t *testing.T, dl safariDownloads) string {
+	t.Helper()
+	path := filepath.Join(t.TempDir(), "Downloads.plist")
+	f, err := os.Create(path)
+	require.NoError(t, err)
+	defer f.Close()
+	require.NoError(t, plist.NewBinaryEncoder(f).Encode(dl))
+	return path
+}
+
+func TestExtractDownloads(t *testing.T) {
+	dl := safariDownloads{
+		DownloadHistory: []safariDownloadEntry{
+			{
+				URL:        "https://example.com/file.zip",
+				Path:       "/Users/test/Downloads/file.zip",
+				TotalBytes: 1024000,
+			},
+			{
+				URL:        "https://go.dev/dl/go1.20.tar.gz",
+				Path:       "/Users/test/Downloads/go1.20.tar.gz",
+				TotalBytes: 98765432,
+			},
+		},
+	}
+
+	path := buildTestDownloadsPlist(t, dl)
+	downloads, err := extractDownloads(path)
+	require.NoError(t, err)
+	require.Len(t, downloads, 2)
+
+	assert.Equal(t, "https://example.com/file.zip", downloads[0].URL)
+	assert.Equal(t, "/Users/test/Downloads/file.zip", downloads[0].TargetPath)
+	assert.Equal(t, int64(1024000), downloads[0].TotalBytes)
+
+	assert.Equal(t, "https://go.dev/dl/go1.20.tar.gz", downloads[1].URL)
+	assert.Equal(t, int64(98765432), downloads[1].TotalBytes)
+}
+
+func TestCountDownloads(t *testing.T) {
+	dl := safariDownloads{
+		DownloadHistory: []safariDownloadEntry{
+			{URL: "https://a.com/1.zip", Path: "/tmp/1.zip", TotalBytes: 100},
+			{URL: "https://b.com/2.zip", Path: "/tmp/2.zip", TotalBytes: 200},
+			{URL: "https://c.com/3.zip", Path: "/tmp/3.zip", TotalBytes: 300},
+		},
+	}
+
+	path := buildTestDownloadsPlist(t, dl)
+	count, err := countDownloads(path)
+	require.NoError(t, err)
+	assert.Equal(t, 3, count)
+}
+
+func TestExtractDownloads_Empty(t *testing.T) {
+	dl := safariDownloads{}
+	path := buildTestDownloadsPlist(t, dl)
+
+	downloads, err := extractDownloads(path)
+	require.NoError(t, err)
+	assert.Empty(t, downloads)
+}