feat: add CountEntries to skip decryption for list --detail (#562)

* feat: add CountEntries to skip decryption for list --detail (#549)
* test: add CountEntries and countCategory tests at browser level
* fix: address review feedback on CountRows and countLocalStorage
* test: add CountRows unit tests

Author: moonD4rk

browser/browser.go

@@ -19,6 +19,7 @@ type Browser interface {
 	ProfileName() string
 	ProfileDir() string
 	Extract(categories []types.Category) (*types.BrowserData, error)
+	CountEntries(categories []types.Category) (map[types.Category]int, error)
 }
 
 // PickOptions configures which browsers to pick.

browser/chromium/chromium.go

@@ -95,6 +95,63 @@ func (b *Browser) Extract(categories []types.Category) (*types.BrowserData, erro
 	return data, nil
 }
 
+// CountEntries copies browser files to a temp directory and counts entries
+// per category without decryption. Much faster than Extract for display-only
+// use cases like "list --detail".
+func (b *Browser) CountEntries(categories []types.Category) (map[types.Category]int, error) {
+	session, err := filemanager.NewSession()
+	if err != nil {
+		return nil, err
+	}
+	defer session.Cleanup()
+
+	tempPaths := b.acquireFiles(session, categories)
+
+	counts := make(map[types.Category]int)
+	for _, cat := range categories {
+		path, ok := tempPaths[cat]
+		if !ok {
+			continue
+		}
+		counts[cat] = b.countCategory(cat, path)
+	}
+	return counts, nil
+}
+
+// countCategory calls the appropriate count function for a category.
+func (b *Browser) countCategory(cat types.Category, path string) int {
+	var count int
+	var err error
+	switch cat {
+	case types.Password:
+		count, err = countPasswords(path)
+	case types.Cookie:
+		count, err = countCookies(path)
+	case types.History:
+		count, err = countHistories(path)
+	case types.Download:
+		count, err = countDownloads(path)
+	case types.Bookmark:
+		count, err = countBookmarks(path)
+	case types.CreditCard:
+		count, err = countCreditCards(path)
+	case types.Extension:
+		if b.cfg.Kind == types.ChromiumOpera {
+			count, err = countOperaExtensions(path)
+		} else {
+			count, err = countExtensions(path)
+		}
+	case types.LocalStorage:
+		count, err = countLocalStorage(path)
+	case types.SessionStorage:
+		count, err = countSessionStorage(path)
+	}
+	if err != nil {
+		log.Debugf("count %s for %s: %v", cat, b.BrowserName()+"/"+b.ProfileName(), err)
+	}
+	return count
+}
+
 // acquireFiles copies source files to the session temp directory.
 func (b *Browser) acquireFiles(session *filemanager.Session, categories []types.Category) map[types.Category]string {
 	tempPaths := make(map[types.Category]string)

browser/chromium/chromium_test.go

@@ -544,17 +544,9 @@ func TestGetMasterKey(t *testing.T) {
 // ---------------------------------------------------------------------------
 
 func TestExtract(t *testing.T) {
-	// Shared fixture: profile with a real History database.
 	dir := t.TempDir()
 	mkFile(dir, "Default", "Preferences")
-
-	historyDB := createTestDB(t, "History", urlsSchema,
-		insertURL("https://example.com", "Example", 5, 13350000000000000),
-	)
-	profileDir := filepath.Join(dir, "Default")
-	data, err := os.ReadFile(historyDB)
-	require.NoError(t, err)
-	require.NoError(t, os.WriteFile(filepath.Join(profileDir, "History"), data, 0o644))
+	installFile(t, filepath.Join(dir, "Default"), setupHistoryDB(t), "History")
 
 	tests := []struct {
 		name          string
@@ -586,7 +578,8 @@ func TestExtract(t *testing.T) {
 			result, err := browsers[0].Extract([]types.Category{types.History})
 			require.NoError(t, err)
 			require.NotNil(t, result)
-			require.Len(t, result.Histories, 1)
+			require.Len(t, result.Histories, 3)
+			// setupHistoryDB: Example(200) > GitHub(100) > Go Dev(50)
 			assert.Equal(t, "Example", result.Histories[0].Title)
 
 			if tt.wantRetriever {
@@ -598,6 +591,87 @@ func TestExtract(t *testing.T) {
 	}
 }
 
+// ---------------------------------------------------------------------------
+// CountEntries
+// ---------------------------------------------------------------------------
+
+func TestCountEntries(t *testing.T) {
+	dir := t.TempDir()
+	mkFile(dir, "Default", "Preferences")
+	installFile(t, filepath.Join(dir, "Default"), setupHistoryDB(t), "History")
+
+	browsers, err := NewBrowsers(types.BrowserConfig{
+		Name: "Test", Kind: types.Chromium, UserDataDir: dir,
+	})
+	require.NoError(t, err)
+	require.Len(t, browsers, 1)
+
+	// No retriever set — CountEntries should still work (no decryption needed).
+	counts, err := browsers[0].CountEntries([]types.Category{types.History, types.Download})
+	require.NoError(t, err)
+
+	assert.Equal(t, 3, counts[types.History])
+	// Download uses a different table in the same file; since we only
+	// created the urls table (not downloads), the count query will fail
+	// gracefully and return 0.
+	assert.Equal(t, 0, counts[types.Download])
+}
+
+func TestCountEntries_NoRetrieverNeeded(t *testing.T) {
+	dir := t.TempDir()
+	mkFile(dir, "Default", "Preferences")
+	// Login Data normally needs master key to extract, but CountEntries skips decryption.
+	installFile(t, filepath.Join(dir, "Default"), setupLoginDB(t), "Login Data")
+
+	browsers, err := NewBrowsers(types.BrowserConfig{
+		Name: "Test", Kind: types.Chromium, UserDataDir: dir,
+	})
+	require.NoError(t, err)
+	require.Len(t, browsers, 1)
+
+	// No retriever set — CountEntries succeeds without master key.
+	counts, err := browsers[0].CountEntries([]types.Category{types.Password})
+	require.NoError(t, err)
+	assert.Equal(t, 2, counts[types.Password])
+}
+
+func TestCountCategory(t *testing.T) {
+	t.Run("History", func(t *testing.T) {
+		path := setupHistoryDB(t)
+		b := &Browser{cfg: types.BrowserConfig{Kind: types.Chromium}}
+		assert.Equal(t, 3, b.countCategory(types.History, path))
+	})
+
+	t.Run("Cookie", func(t *testing.T) {
+		path := setupCookieDB(t)
+		b := &Browser{cfg: types.BrowserConfig{Kind: types.Chromium}}
+		assert.Equal(t, 2, b.countCategory(types.Cookie, path))
+	})
+
+	t.Run("Bookmark", func(t *testing.T) {
+		path := setupBookmarkJSON(t)
+		b := &Browser{cfg: types.BrowserConfig{Kind: types.Chromium}}
+		assert.Equal(t, 3, b.countCategory(types.Bookmark, path))
+	})
+
+	t.Run("Extension_Opera", func(t *testing.T) {
+		path := createTestJSON(t, "Secure Preferences", `{
+			"extensions": {
+				"opsettings": {
+					"ext1": {"location": 1, "manifest": {"name": "Ext", "version": "1.0"}}
+				}
+			}
+		}`)
+		b := &Browser{cfg: types.BrowserConfig{Kind: types.ChromiumOpera}}
+		assert.Equal(t, 1, b.countCategory(types.Extension, path))
+	})
+
+	t.Run("FileNotFound", func(t *testing.T) {
+		b := &Browser{cfg: types.BrowserConfig{Kind: types.Chromium}}
+		assert.Equal(t, 0, b.countCategory(types.History, "/nonexistent/path"))
+	})
+}
+
 // ---------------------------------------------------------------------------
 // SetRetriever: verify *Browser satisfies the interface used by
 // browser.pickFromConfigs for post-construction retriever injection.

browser/chromium/extract_bookmark.go

@@ -51,3 +51,32 @@ func walkBookmarks(node gjson.Result, folder string, out *[]types.BookmarkEntry)
 		walkBookmarks(child, currentFolder, out)
 	}
 }
+
+func countBookmarks(path string) (int, error) {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return 0, err
+	}
+	var count int
+	roots := gjson.GetBytes(data, "roots")
+	roots.ForEach(func(_, value gjson.Result) bool {
+		count += walkCountBookmarks(value)
+		return true
+	})
+	return count, nil
+}
+
+// walkCountBookmarks recursively counts URL nodes in the bookmark tree.
+func walkCountBookmarks(node gjson.Result) int {
+	count := 0
+	if node.Get("type").String() == "url" {
+		count++
+	}
+	children := node.Get("children")
+	if children.Exists() && children.IsArray() {
+		for _, child := range children.Array() {
+			count += walkCountBookmarks(child)
+		}
+	}
+	return count
+}

browser/chromium/extract_bookmark_test.go

@@ -7,8 +7,9 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestExtractBookmarks(t *testing.T) {
-	path := createTestJSON(t, "Bookmarks", `{
+func setupBookmarkJSON(t *testing.T) string {
+	t.Helper()
+	return createTestJSON(t, "Bookmarks", `{
 		"roots": {
 			"bookmark_bar": {
 				"name": "Bookmarks Bar",
@@ -33,6 +34,10 @@ func TestExtractBookmarks(t *testing.T) {
 			}
 		}
 	}`)
+}
+
+func TestExtractBookmarks(t *testing.T) {
+	path := setupBookmarkJSON(t)
 
 	got, err := extractBookmarks(path)
 	require.NoError(t, err)
@@ -52,6 +57,22 @@ func TestExtractBookmarks(t *testing.T) {
 	assert.Equal(t, "News", got[2].Folder) // parent folder name
 }
 
+func TestCountBookmarks(t *testing.T) {
+	path := setupBookmarkJSON(t)
+
+	count, err := countBookmarks(path)
+	require.NoError(t, err)
+	assert.Equal(t, 3, count) // 3 URLs, folders not counted
+}
+
+func TestCountBookmarks_Empty(t *testing.T) {
+	path := createTestJSON(t, "Bookmarks", `{"roots": {}}`)
+
+	count, err := countBookmarks(path)
+	require.NoError(t, err)
+	assert.Equal(t, 0, count)
+}
+
 func TestExtractBookmarks_FoldersExcluded(t *testing.T) {
 	path := createTestJSON(t, "Bookmarks", `{
 		"roots": {

browser/chromium/extract_cookie.go

@@ -11,9 +11,12 @@ import (
 	"github.com/moond4rk/hackbrowserdata/utils/sqliteutil"
 )
 
-const defaultCookieQuery = `SELECT name, encrypted_value, host_key, path,
-	creation_utc, expires_utc, is_secure, is_httponly,
-	has_expires, is_persistent FROM cookies`
+const (
+	defaultCookieQuery = `SELECT name, encrypted_value, host_key, path,
+		creation_utc, expires_utc, is_secure, is_httponly,
+		has_expires, is_persistent FROM cookies`
+	countCookieQuery = `SELECT COUNT(*) FROM cookies`
+)
 
 func extractCookies(masterKey []byte, path string) ([]types.CookieEntry, error) {
 	var decryptFails int
@@ -65,6 +68,10 @@ func extractCookies(masterKey []byte, path string) ([]types.CookieEntry, error)
 	return cookies, nil
 }
 
+func countCookies(path string) (int, error) {
+	return sqliteutil.CountRows(path, false, countCookieQuery)
+}
+
 // stripCookieHash removes the SHA256(host_key) prefix from a decrypted cookie value.
 // Chrome 130+ (Cookie DB schema version 24) prepends SHA256(domain) to the cookie
 // value before encryption to prevent cross-domain cookie replay attacks.

browser/chromium/extract_cookie_test.go

@@ -8,11 +8,16 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestExtractCookies(t *testing.T) {
-	path := createTestDB(t, "Cookies", cookiesSchema,
+func setupCookieDB(t *testing.T) string {
+	t.Helper()
+	return createTestDB(t, "Cookies", cookiesSchema,
 		insertCookie("session", ".old.com", "/", "", 13340000000000000, 13350000000000000, 1, 1),
 		insertCookie("token", ".new.com", "/api", "", 13360000000000000, 13370000000000000, 1, 0),
 	)
+}
+
+func TestExtractCookies(t *testing.T) {
+	path := setupCookieDB(t)
 
 	got, err := extractCookies(nil, path)
 	require.NoError(t, err)
@@ -34,6 +39,22 @@ func TestExtractCookies(t *testing.T) {
 	assert.True(t, got[1].IsHTTPOnly)
 }
 
+func TestCountCookies(t *testing.T) {
+	path := setupCookieDB(t)
+
+	count, err := countCookies(path)
+	require.NoError(t, err)
+	assert.Equal(t, 2, count)
+}
+
+func TestCountCookies_Empty(t *testing.T) {
+	path := createTestDB(t, "Cookies", cookiesSchema)
+
+	count, err := countCookies(path)
+	require.NoError(t, err)
+	assert.Equal(t, 0, count)
+}
+
 func TestStripCookieHash(t *testing.T) {
 	googleHash := sha256.Sum256([]byte(".google.com"))
 	shopifyHash := sha256.Sum256([]byte(".shopify.com"))

browser/chromium/extract_creditcard.go

@@ -8,8 +8,11 @@ import (
 	"github.com/moond4rk/hackbrowserdata/utils/sqliteutil"
 )
 
-const defaultCreditCardQuery = `SELECT COALESCE(guid, ''), name_on_card, expiration_month, expiration_year,
-	card_number_encrypted, COALESCE(nickname, ''), COALESCE(billing_address_id, '') FROM credit_cards`
+const (
+	defaultCreditCardQuery = `SELECT COALESCE(guid, ''), name_on_card, expiration_month, expiration_year,
+		card_number_encrypted, COALESCE(nickname, ''), COALESCE(billing_address_id, '') FROM credit_cards`
+	countCreditCardQuery = `SELECT COUNT(*) FROM credit_cards`
+)
 
 func extractCreditCards(masterKey []byte, path string) ([]types.CreditCardEntry, error) {
 	var decryptFails int
@@ -44,3 +47,7 @@ func extractCreditCards(masterKey []byte, path string) ([]types.CreditCardEntry,
 	}
 	return cards, nil
 }
+
+func countCreditCards(path string) (int, error) {
+	return sqliteutil.CountRows(path, false, countCreditCardQuery)
+}

browser/chromium/extract_creditcard_test.go

@@ -7,11 +7,16 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestExtractCreditCards(t *testing.T) {
-	path := createTestDB(t, "Web Data", creditCardsSchema,
+func setupCreditCardDB(t *testing.T) string {
+	t.Helper()
+	return createTestDB(t, "Web Data", creditCardsSchema,
 		insertCreditCard("John Doe", 12, 2025, "", "Johnny", "addr-1"),
 		insertCreditCard("Jane Smith", 6, 2027, "", "", ""),
 	)
+}
+
+func TestExtractCreditCards(t *testing.T) {
+	path := setupCreditCardDB(t)
 
 	got, err := extractCreditCards(nil, path)
 	require.NoError(t, err)
@@ -28,3 +33,19 @@ func TestExtractCreditCards(t *testing.T) {
 	assert.Equal(t, "6", got[1].ExpMonth)
 	assert.Equal(t, "2027", got[1].ExpYear)
 }
+
+func TestCountCreditCards(t *testing.T) {
+	path := setupCreditCardDB(t)
+
+	count, err := countCreditCards(path)
+	require.NoError(t, err)
+	assert.Equal(t, 2, count)
+}
+
+func TestCountCreditCards_Empty(t *testing.T) {
+	path := createTestDB(t, "Web Data", creditCardsSchema)
+
+	count, err := countCreditCards(path)
+	require.NoError(t, err)
+	assert.Equal(t, 0, count)
+}