feat: add visit tracking to items and filter groups for URLs only

- Add visitCount and lastVisitAt fields to Item interface
- Add items table columns and migration for visit tracking
- Update addVisit() to also update matching items when URL is visited
- Update groups extension to:
- Handle both Address (uri) and Item (content) objects
- Parse metadata.title for items
- Filter to show only URL items (not text/tagset/image)
- Add test:sync:desktop script for server+desktop sync testing
- Creates temp profile that's cleaned up on exit
- Pre-configures sync and runs initial pull
- Seeds test data on server

backend/electron/datastore.ts

···
     updatedAt INTEGER NOT NULL,
     deletedAt INTEGER DEFAULT 0,
     starred INTEGER DEFAULT 0,
-    archived INTEGER DEFAULT 0
+    archived INTEGER DEFAULT 0,
+    visitCount INTEGER DEFAULT 0,
+    lastVisitAt INTEGER DEFAULT 0
   );
   CREATE INDEX IF NOT EXISTS idx_items_type ON items(type);
   CREATE INDEX IF NOT EXISTS idx_items_syncId ON items(syncId);
···
   migrateTinyBaseData();
   migrateSyncColumns();
   migrateItemTypes();
+  migrateItemVisitColumns();
 
   DEBUG && console.log('main', 'database initialized successfully');
   return db;
···
   }
 }
 
+/**
+ * Add visit tracking columns to items table for existing databases
+ */
+function migrateItemVisitColumns(): void {
+  if (!db) return;
+
+  const columns = db.prepare(`PRAGMA table_info(items)`).all() as { name: string }[];
+  const hasVisitCount = columns.some(col => col.name === 'visitCount');
+
+  if (!hasVisitCount) {
+    DEBUG && console.log('main', 'Adding visit columns to items table');
+    try {
+      db.exec(`ALTER TABLE items ADD COLUMN visitCount INTEGER DEFAULT 0`);
+      db.exec(`ALTER TABLE items ADD COLUMN lastVisitAt INTEGER DEFAULT 0`);
+    } catch (error) {
+      DEBUG && console.log('main', `Visit columns migration for items:`, (error as Error).message);
+    }
+  }
+
+  // Always ensure indexes exist (handles both new and migrated tables)
+  try {
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_items_lastVisitAt ON items(lastVisitAt)`);
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_items_visitCount ON items(visitCount)`);
+  } catch (error) {
+    DEBUG && console.log('main', `Visit indexes for items:`, (error as Error).message);
+  }
+}
+
 // ==================== Address Operations ====================
 
 export function addAddress(uri: string, options: AddressOptions = {}): { id: string } {
···
     UPDATE addresses SET lastVisitAt = ?, visitCount = visitCount + 1, updatedAt = ?
     WHERE id = ?
   `).run(timestamp, timestamp, addressId);
+
+  // Also update any items with matching URL content
+  const address = getAddress(addressId);
+  if (address && address.uri) {
+    getDb().prepare(`
+      UPDATE items SET lastVisitAt = ?, visitCount = visitCount + 1, updatedAt = ?
+      WHERE type = 'url' AND content = ? AND deletedAt = 0
+    `).run(timestamp, timestamp, address.uri);
+  }
 
   return { id: visitId };
 }

backend/types/index.ts

···
   deletedAt: number;
   starred: number;
   archived: number;
+  visitCount: number;
+  lastVisitAt: number;
 }
 
 export interface ItemTag {

extensions/groups/home.js

···
     state.tags = result.data;
     debug && console.log('Loaded tags:', state.tags.length);
 
-    // Fetch item count for each tag
+    // Fetch URL item count for each tag (only URLs for now)
     for (const tag of state.tags) {
       const itemsResult = await api.datastore.getItemsByTag(tag.id);
-      tag.addressCount = itemsResult.success ? itemsResult.data.length : 0;
+      if (itemsResult.success) {
+        tag.addressCount = itemsResult.data.filter(item => item.type === 'url').length;
+      } else {
+        tag.addressCount = 0;
+      }
     }
   } else {
     console.error('Failed to load tags:', result.error);
     state.tags = [];
   }
 
-  // Get count of untagged items
+  // Get count of untagged URL items (only URLs for now)
   // Query all items and filter out those with tags
   const allItemsResult = await api.datastore.queryItems({});
   if (allItemsResult.success) {
     const untaggedItems = [];
     for (const item of allItemsResult.data) {
+      // Only include URL items
+      if (item.type !== 'url') continue;
       const tagsResult = await api.datastore.getItemTags(item.id);
       if (tagsResult.success && tagsResult.data.length === 0) {
         untaggedItems.push(item);
       }
     }
     state.untaggedCount = untaggedItems.length;
-    debug && console.log('Untagged items:', state.untaggedCount);
+    debug && console.log('Untagged URL items:', state.untaggedCount);
   } else {
     state.untaggedCount = 0;
   }
 };
 
 /**
- * Load items for a specific tag
+ * Load URL items for a specific tag (only URLs for now)
  */
 const loadAddressesForTag = async (tagId) => {
   const result = await api.datastore.getItemsByTag(tagId);
   if (result.success) {
-    state.addresses = result.data;
-    debug && console.log('Loaded items for tag:', state.addresses.length);
+    // Only include URL items
+    state.addresses = result.data.filter(item => item.type === 'url');
+    debug && console.log('Loaded URL items for tag:', state.addresses.length);
   } else {
     console.error('Failed to load addresses:', result.error);
     state.addresses = [];
···
 
 /**
  * Filter addresses by search query (title or URL)
+ * Handles both Address (uri) and Item (content) objects
  */
 const filterAddresses = (addresses) => {
   if (!state.searchQuery) return addresses;
   const q = state.searchQuery.toLowerCase();
-  return addresses.filter(addr =>
-    (addr.title || '').toLowerCase().includes(q) ||
-    addr.uri.toLowerCase().includes(q)
-  );
+  return addresses.filter(addr => {
+    const url = addr.uri || addr.content || '';
+    return (addr.title || '').toLowerCase().includes(q) ||
+      url.toLowerCase().includes(q);
+  });
 };
 
 /**
···
   state.currentTag = tag;
   state.searchQuery = '';
 
-  // Load items - handle special untagged group
+  // Load URL items - handle special untagged group (only URLs for now)
   if (tag.isSpecial && tag.id === '__untagged__') {
     const allItemsResult = await api.datastore.queryItems({});
     if (allItemsResult.success) {
       const untaggedItems = [];
       for (const item of allItemsResult.data) {
+        // Only include URL items
+        if (item.type !== 'url') continue;
         const tagsResult = await api.datastore.getItemTags(item.id);
         if (tagsResult.success && tagsResult.data.length === 0) {
           untaggedItems.push(item);
···
 
 /**
  * Create a card element for an address
+ * Handles both Address (uri) and Item (content) objects
  */
 const createAddressCard = (address) => {
   const card = document.createElement('div');
   card.className = 'card address-card';
   card.dataset.addressId = address.id;
 
+  // Get URL from either uri (Address) or content (Item)
+  const addressUrl = address.uri || address.content;
+
+  // Get title - Items store title in metadata, Addresses have it directly
+  let displayTitle = address.title;
+  if (!displayTitle && address.metadata) {
+    try {
+      const meta = typeof address.metadata === 'string' ? JSON.parse(address.metadata) : address.metadata;
+      displayTitle = meta.title;
+    } catch (e) {
+      // Ignore parse errors
+    }
+  }
+  displayTitle = displayTitle || addressUrl;
+
   const favicon = document.createElement('img');
   favicon.className = 'card-favicon';
   favicon.src = address.favicon || 'data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100"><text y=".9em" font-size="90">🌐</text></svg>';
···
 
   const title = document.createElement('h2');
   title.className = 'card-title';
-  title.textContent = address.title || address.uri;
+  title.textContent = displayTitle;
 
   const url = document.createElement('div');
   url.className = 'card-url';
-  url.textContent = address.uri;
+  url.textContent = addressUrl;
 
   const meta = document.createElement('div');
   meta.className = 'card-meta';
···
 
   // Click to open address
   card.addEventListener('click', async () => {
-    debug && console.log('Opening address:', address.uri);
-    const result = await api.window.open(address.uri, {
+    debug && console.log('Opening address:', addressUrl);
+    const result = await api.window.open(addressUrl, {
       width: 800,
       height: 600
     });

package.json

···
     "test:sync:e2e:prod": "node backend/tests/sync-e2e-prod.test.js",
     "test:sync:e2e:prod:verbose": "VERBOSE=1 node backend/tests/sync-e2e-prod.test.js",
     "test:sync:verify-logs": "node backend/tests/verify-railway-logs.js",
+    "test:sync:desktop": "./scripts/test-sync-desktop.sh",
     "test:mobile": "cd backend/tauri-mobile && npm test",
     "//-- Packaged Electron --//": "",
     "kill:packaged": "pkill -f 'out/mac-arm64/Peek.app' || true",

scripts/preconfigure-sync.mjs

···
+/**
+ * Pre-configure sync settings and run initial sync for test profile
+ *
+ * This script must be run with Electron (not Node) because better-sqlite3
+ * is compiled for Electron's Node version.
+ *
+ * Usage: electron scripts/preconfigure-sync.mjs
+ *
+ * Environment variables:
+ * - PROFILE: Profile name (required)
+ * - SERVER_URL: Sync server URL (required)
+ * - API_KEY: Server API key (required)
+ */
+
+import { app } from 'electron';
+import { join } from 'path';
+import { mkdirSync, existsSync } from 'fs';
+import { homedir } from 'os';
+
+// Prevent Electron from showing a window
+app.disableHardwareAcceleration();
+
+const PROFILE = process.env.PROFILE;
+const SERVER_URL = process.env.SERVER_URL;
+const API_KEY = process.env.API_KEY;
+
+if (!PROFILE || !SERVER_URL || !API_KEY) {
+  console.error('Missing required environment variables: PROFILE, SERVER_URL, API_KEY');
+  process.exit(1);
+}
+
+app.whenReady().then(async () => {
+  // Import compiled modules (after app is ready)
+  const datastore = await import('../dist/backend/electron/datastore.js');
+  const sync = await import('../dist/backend/electron/sync.js');
+  const profiles = await import('../dist/backend/electron/profiles.js');
+
+  // Paths
+  const userDataPath = join(homedir(), 'Library', 'Application Support', 'Peek');
+  const profileDir = join(userDataPath, PROFILE);
+  const dbPath = join(profileDir, 'datastore.sqlite');
+
+  console.log(`  Profile: ${PROFILE}`);
+  console.log(`  Database: ${dbPath}`);
+  console.log(`  Server: ${SERVER_URL}`);
+
+  // Create profile directory if needed
+  if (!existsSync(profileDir)) {
+    mkdirSync(profileDir, { recursive: true });
+    console.log('  Created profile directory');
+  }
+
+  // Initialize profiles database (uses .dev-profiles.db for dev builds)
+  profiles.initProfilesDb(userDataPath, '.dev-profiles.db');
+  profiles.migrateExistingProfiles();
+  profiles.ensureDefaultProfile();
+
+  // Create the test profile if it doesn't exist
+  try {
+    const existingProfile = profiles.getProfile(PROFILE);
+    if (!existingProfile) {
+      profiles.createProfile(PROFILE);
+      console.log('  Created test profile in profiles.db');
+    }
+  } catch (error) {
+    // Profile might already exist with different name
+    console.log(`  Profile setup: ${error.message}`);
+  }
+
+  // Set this profile as active
+  try {
+    profiles.setActiveProfile(PROFILE);
+    console.log('  Set active profile');
+  } catch (error) {
+    console.log(`  Could not set active profile: ${error.message}`);
+  }
+
+  // Initialize datastore
+  datastore.initDatabase(dbPath);
+  console.log('  Database initialized');
+
+  // Enable sync for this profile
+  const activeProfile = profiles.getActiveProfile();
+  profiles.enableSync(activeProfile.id, API_KEY, 'default');
+
+  // Set server URL globally
+  sync.setSyncConfig({
+    serverUrl: SERVER_URL,
+    apiKey: API_KEY,
+    lastSyncTime: 0,
+    autoSync: false,
+  });
+  console.log('  Sync configured');
+
+  // Run initial sync (pull from server)
+  try {
+    const result = await sync.pullFromServer(SERVER_URL, API_KEY);
+    console.log(`  Pulled ${result.pulled} items from server`);
+  } catch (error) {
+    console.error('  Sync failed:', error.message);
+    datastore.closeDatabase();
+    profiles.closeProfilesDb();
+    app.exit(1);
+    return;
+  }
+
+  // Close databases
+  datastore.closeDatabase();
+  profiles.closeProfilesDb();
+  console.log('  Pre-configuration complete');
+
+  app.exit(0);
+});
+
+// Handle window-all-closed to prevent default behavior
+app.on('window-all-closed', () => {
+  // Do nothing - we'll exit manually
+});

scripts/test-sync-desktop.sh

···
+#!/bin/bash
+# Desktop + Server sync test environment
+# Creates temp profile for desktop and temp data dir for server
+# Pre-configures sync settings and runs initial sync
+# Cleans up everything on exit
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+ROOT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+SERVER_DIR="$ROOT_DIR/backend/server"
+
+# Generate unique identifiers
+TIMESTAMP=$(date +%s)
+PROFILE_NAME="test-sync-$TIMESTAMP"
+SERVER_TEMP_DIR=$(mktemp -d)
+API_KEY="test-sync-key-$TIMESTAMP"
+PORT=$((RANDOM % 10000 + 20000))
+SERVER_URL="http://localhost:$PORT"
+
+# Get userData path (macOS)
+USER_DATA_PATH="$HOME/Library/Application Support/Peek"
+PROFILE_DIR="$USER_DATA_PATH/$PROFILE_NAME"
+
+echo "=========================================="
+echo "  Desktop + Server Sync Test Environment"
+echo "=========================================="
+echo ""
+echo "Profile:     $PROFILE_NAME"
+echo "Profile dir: $PROFILE_DIR"
+echo "Server temp: $SERVER_TEMP_DIR"
+echo "Server URL:  $SERVER_URL"
+echo "API Key:     $API_KEY"
+echo ""
+
+# Cleanup function
+cleanup() {
+    echo ""
+    echo "Cleaning up..."
+
+    # Kill background processes
+    if [ -n "$SERVER_PID" ]; then
+        echo "  Stopping server (PID: $SERVER_PID)..."
+        kill $SERVER_PID 2>/dev/null || true
+    fi
+
+    if [ -n "$DESKTOP_PID" ]; then
+        echo "  Stopping desktop (PID: $DESKTOP_PID)..."
+        kill $DESKTOP_PID 2>/dev/null || true
+    fi
+
+    # Wait for processes to exit
+    sleep 1
+
+    # Remove temp directories
+    if [ -d "$SERVER_TEMP_DIR" ]; then
+        echo "  Removing server temp dir: $SERVER_TEMP_DIR"
+        rm -rf "$SERVER_TEMP_DIR"
+    fi
+
+    if [ -d "$PROFILE_DIR" ]; then
+        echo "  Removing profile dir: $PROFILE_DIR"
+        rm -rf "$PROFILE_DIR"
+    fi
+
+    echo "Cleanup complete."
+    exit 0
+}
+
+trap cleanup SIGINT SIGTERM EXIT
+
+# Build first
+echo "Building..."
+cd "$ROOT_DIR"
+yarn build
+
+# Start server
+echo ""
+echo "Starting server..."
+cd "$SERVER_DIR"
+DATA_DIR="$SERVER_TEMP_DIR" API_KEY="$API_KEY" PORT="$PORT" node index.js &
+SERVER_PID=$!
+echo "  Server started (PID: $SERVER_PID)"
+
+# Wait for server to be ready
+echo "  Waiting for server..."
+for i in {1..30}; do
+    if curl -s "$SERVER_URL/" > /dev/null 2>&1; then
+        echo "  Server is ready"
+        break
+    fi
+    sleep 0.1
+done
+
+# Seed test data on server
+echo ""
+echo "Seeding test data on server..."
+curl -s -X POST "$SERVER_URL/items" \
+    -H "Authorization: Bearer $API_KEY" \
+    -H "Content-Type: application/json" \
+    -d '{"type":"url","content":"https://example.com/synced-url-1","tags":["test","synced"],"metadata":{"title":"Example Synced URL"}}' > /dev/null
+
+curl -s -X POST "$SERVER_URL/items" \
+    -H "Authorization: Bearer $API_KEY" \
+    -H "Content-Type: application/json" \
+    -d '{"type":"url","content":"https://github.com/test/repo","tags":["test","github"],"metadata":{"title":"Test Repository - GitHub"}}' > /dev/null
+
+curl -s -X POST "$SERVER_URL/items" \
+    -H "Authorization: Bearer $API_KEY" \
+    -H "Content-Type: application/json" \
+    -d '{"type":"text","content":"This is a synced text note","tags":["test","note"]}' > /dev/null
+
+echo "  Seeded 3 test items"
+
+# Pre-configure sync and run initial sync (must use electron, not node, for better-sqlite3)
+echo ""
+echo "Pre-configuring sync and running initial sync..."
+cd "$ROOT_DIR"
+PROFILE="$PROFILE_NAME" SERVER_URL="$SERVER_URL" API_KEY="$API_KEY" electron scripts/preconfigure-sync.mjs
+
+# Start desktop with temp profile
+echo ""
+echo "Starting desktop with profile: $PROFILE_NAME"
+cd "$ROOT_DIR"
+PROFILE="$PROFILE_NAME" DEBUG=1 electron . &
+DESKTOP_PID=$!
+echo "  Desktop started (PID: $DESKTOP_PID)"
+
+# Print instructions
+echo ""
+echo "=========================================="
+echo "  Test Environment Ready!"
+echo "=========================================="
+echo ""
+echo "Sync is pre-configured and initial sync completed."
+echo "Open the Groups extension to see synced items."
+echo ""
+echo "Test data synced from server:"
+echo "  - https://example.com/synced-url-1 (tags: test, synced)"
+echo "  - https://github.com/test/repo (tags: test, github)"
+echo "  - Text note: 'This is a synced text note'"
+echo ""
+echo "Press Ctrl+C to stop and clean up."
+echo "=========================================="
+echo ""
+
+# Wait for processes
+wait