npm - @bobfrankston/gcards - Versions diffs - 0.1.20 → 0.1.22 - Mend

@bobfrankston/gcards 0.1.20 → 0.1.22

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/gcards.ts CHANGED Viewed

@@ -8,6 +8,7 @@ import fs from 'fs';
 import fp from 'fs/promises';
 import path from 'path';
 import crypto from 'crypto';
+import { parse as parseJsonc } from 'jsonc-parser';
 import { parseArgs, showUsage, showHelp } from './glib/parsecli.ts';
 import { authenticateOAuth } from '../../../projects/oauth/oauthsupport/index.ts';
 import type { GooglePerson, GoogleConnectionsResponse } from './glib/types.ts';
@@ -160,7 +161,11 @@ interface DeletedIndex {
 function loadDeleted(paths: UserPaths): DeletedIndex {
     if (fs.existsSync(paths.deletedFile)) {
-        return JSON.parse(fs.readFileSync(paths.deletedFile, 'utf-8'));
+        try {
+            return parseJsonc(fs.readFileSync(paths.deletedFile, 'utf-8'));
+        } catch (e: any) {
+            throw new Error(`Failed to parse ${paths.deletedFile}: ${e.message}`);
+        }
     }
     return { deleted: {} };
 }
@@ -194,7 +199,11 @@ interface PhotosIndex {
 function loadPhotos(paths: UserPaths): PhotosIndex {
     if (fs.existsSync(paths.photosFile)) {
-        return JSON.parse(fs.readFileSync(paths.photosFile, 'utf-8'));
+        try {
+            return parseJsonc(fs.readFileSync(paths.photosFile, 'utf-8'));
+        } catch (e: any) {
+            throw new Error(`Failed to parse ${paths.photosFile}: ${e.message}`);
+        }
     }
     return { photos: {} };
 }
@@ -208,12 +217,55 @@ function savePhotos(paths: UserPaths, photosIndex: PhotosIndex): void {
         sorted[key] = value;
     }
     photosIndex.photos = sorted;
+    // Save JSON data file
     fs.writeFileSync(paths.photosFile, JSON.stringify(photosIndex, null, 2));
+    // Generate HTML view
+    const html = `<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>Saved Photos from Deleted Contacts</title>
+    <style>
+        body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; margin: 20px; }
+        h1 { color: #333; }
+        table { border-collapse: collapse; width: 100%; }
+        th, td { border: 1px solid #ddd; padding: 8px; text-align: left; vertical-align: middle; }
+        th { background: #f5f5f5; }
+        tr:hover { background: #f9f9f9; }
+        img { width: 100px; height: 100px; object-fit: cover; border-radius: 4px; }
+        a { color: #1a73e8; text-decoration: none; }
+        a:hover { text-decoration: underline; }
+        .deleted { font-size: 12px; color: #666; }
+    </style>
+</head>
+<body>
+    <h1>Saved Photos from Deleted Contacts (${entries.length})</h1>
+    <table>
+        <tr><th>Photo</th><th>Name</th></tr>
+${entries.map(([resourceName, entry]) => {
+    const id = resourceName.replace('people/', '');
+    const contactUrl = `https://contacts.google.com/person/${id}`;
+    const photoUrl = entry.photos[0]?.url || '';
+    return `        <tr>
+            <td>${photoUrl ? `<img src="${photoUrl}" alt="${entry.displayName}" loading="lazy">` : '(no photo)'}</td>
+            <td><a href="${contactUrl}" target="_blank">${entry.displayName}</a><br><span class="deleted">Deleted: ${entry.deletedAt?.split('T')[0] || 'unknown'}</span></td>
+        </tr>`;
+}).join('\n')}
+    </table>
+</body>
+</html>`;
+    fs.writeFileSync(paths.photosHtmlFile, html);
 }
 function loadDeleteQueue(paths: UserPaths): DeleteQueue {
     if (fs.existsSync(paths.deleteQueueFile)) {
-        return JSON.parse(fs.readFileSync(paths.deleteQueueFile, 'utf-8'));
+        try {
+            return parseJsonc(fs.readFileSync(paths.deleteQueueFile, 'utf-8'));
+        } catch (e: any) {
+            throw new Error(`Failed to parse ${paths.deleteQueueFile}: ${e.message}`);
+        }
     }
     return { updatedAt: '', entries: [] };
 }
@@ -249,8 +301,12 @@ function generateGuid(): string {
 function loadSyncToken(paths: UserPaths): string {
     if (fs.existsSync(paths.syncTokenFile)) {
-        const data = JSON.parse(fs.readFileSync(paths.syncTokenFile, 'utf-8'));
-        return data.syncToken || null;
+        try {
+            const data = parseJsonc(fs.readFileSync(paths.syncTokenFile, 'utf-8'));
+            return data.syncToken || null;
+        } catch (e: any) {
+            throw new Error(`Failed to parse ${paths.syncTokenFile}: ${e.message}`);
+        }
     }
     return null;
 }
@@ -439,7 +495,7 @@ async function syncContacts(user: string, options: { full: boolean; verbose: boo
                         // Save photos before deleting
                         if (fs.existsSync(contactFile)) {
                             try {
-                                const contact = JSON.parse(fs.readFileSync(contactFile, 'utf-8')) as GooglePerson;
+                                const contact = parseJsonc(fs.readFileSync(contactFile, 'utf-8')) as GooglePerson;
                                 const photos = extractNonDefaultPhotos(contact);
                                 if (photos.length > 0) {
                                     photosIndex.photos[person.resourceName] = {
@@ -461,12 +517,16 @@ async function syncContacts(user: string, options: { full: boolean; verbose: boo
                             if (!fs.existsSync(paths.deletedDir)) {
                                 fs.mkdirSync(paths.deletedDir, { recursive: true });
                             }
-                            const contactData = JSON.parse(fs.readFileSync(contactFile, 'utf-8'));
-                            contactData._deletedAt = new Date().toISOString();
-                            contactData._delete = 'server';
-                            const destPath = path.join(paths.deletedDir, `${id}.json`);
-                            fs.writeFileSync(destPath, JSON.stringify(contactData, null, 2));
-                            fs.unlinkSync(contactFile);
+                            try {
+                                const contactData = parseJsonc(fs.readFileSync(contactFile, 'utf-8'));
+                                contactData._deletedAt = new Date().toISOString();
+                                contactData._delete = 'server';
+                                const destPath = path.join(paths.deletedDir, `${id}.json`);
+                                fs.writeFileSync(destPath, JSON.stringify(contactData, null, 2));
+                                fs.unlinkSync(contactFile);
+                            } catch (e: any) {
+                                console.error(`\n[PARSE ERROR] ${id}.json: ${e.message}`);
+                            }
                         }
                         deleted++;
@@ -568,7 +628,11 @@ async function syncContacts(user: string, options: { full: boolean; verbose: boo
 function loadStatus(paths: UserPaths): PushStatus {
     if (fs.existsSync(paths.statusFile)) {
-        return JSON.parse(fs.readFileSync(paths.statusFile, 'utf-8'));
+        try {
+            return parseJsonc(fs.readFileSync(paths.statusFile, 'utf-8'));
+        } catch (e: any) {
+            throw new Error(`Failed to parse ${paths.statusFile}: ${e.message}`);
+        }
     }
     return { lastPush: '' };
 }
@@ -628,7 +692,7 @@ async function findPendingChanges(paths: UserPaths, logger: FileLogger, since?:
             checked++;
             let content: GooglePerson & { _delete?: boolean };
             try {
-                content = JSON.parse(await fp.readFile(filePath, 'utf-8'));
+                content = parseJsonc(await fp.readFile(filePath, 'utf-8'));
             } catch (e: any) {
                 const errMsg = `[PARSE ERROR] ${file}: ${e.message}`;
                 parseErrors.push(errMsg);
@@ -666,7 +730,7 @@ async function findPendingChanges(paths: UserPaths, logger: FileLogger, since?:
             const filePath = path.join(paths.toDeleteDir, file);
             let content: GooglePerson & { _delete?: string | boolean };
             try {
-                content = JSON.parse(await fp.readFile(filePath, 'utf-8'));
+                content = parseJsonc(await fp.readFile(filePath, 'utf-8'));
             } catch (e: any) {
                 const errMsg = `[PARSE ERROR] ${file}: ${e.message}`;
                 parseErrors.push(errMsg);
@@ -692,7 +756,7 @@ async function findPendingChanges(paths: UserPaths, logger: FileLogger, since?:
             const filePath = path.join(paths.toAddDir, file);
             let content: GooglePerson;
             try {
-                content = JSON.parse(await fp.readFile(filePath, 'utf-8'));
+                content = parseJsonc(await fp.readFile(filePath, 'utf-8'));
             } catch (e: any) {
                 const errMsg = `[PARSE ERROR] ${file}: ${e.message}`;
                 parseErrors.push(errMsg);
@@ -962,7 +1026,7 @@ async function pushContacts(user: string, options: { yes: boolean; verbose: bool
         processed++;
         try {
             if (change.type === 'add') {
-                const content = JSON.parse(fs.readFileSync(change.filePath, 'utf-8')) as GooglePerson;
+                const content = parseJsonc(fs.readFileSync(change.filePath, 'utf-8')) as GooglePerson;
                 process.stdout.write(`${ts()} [${String(processed).padStart(5)}/${total}] Creating ${change.displayName}...`);
                 const created = await createContactOnGoogle(content);
@@ -996,7 +1060,7 @@ async function pushContacts(user: string, options: { yes: boolean; verbose: bool
                 console.log(` done (${created.resourceName})`);
                 successCount++;
             } else if (change.type === 'update') {
-                const content = JSON.parse(fs.readFileSync(change.filePath, 'utf-8')) as GooglePerson;
+                const content = parseJsonc(fs.readFileSync(change.filePath, 'utf-8')) as GooglePerson;
                 process.stdout.write(`${ts()} [${String(processed).padStart(5)}/${total}] Updating ${change.displayName}...`);
                 await updateContactOnGoogle(content);
@@ -1017,7 +1081,7 @@ async function pushContacts(user: string, options: { yes: boolean; verbose: bool
                 let isForced = change._delete === 'force' || index.contacts[change.resourceName]?._delete === 'force';
                 if (fs.existsSync(fileToRead)) {
                     try {
-                        const contact = JSON.parse(fs.readFileSync(fileToRead, 'utf-8')) as GooglePerson;
+                        const contact = parseJsonc(fs.readFileSync(fileToRead, 'utf-8')) as GooglePerson;
                         contactHasPhoto = hasNonDefaultPhoto(contact);
                         contactIsStarred = isStarred(contact);
                         if ((contact as any)._delete === 'force') isForced = true;
@@ -1071,7 +1135,7 @@ async function pushContacts(user: string, options: { yes: boolean; verbose: bool
                     }
                     if (fs.existsSync(contactFile)) {
                         // Add deletion metadata to the JSON file
-                        const contactData = JSON.parse(fs.readFileSync(contactFile, 'utf-8'));
+                        const contactData = parseJsonc(fs.readFileSync(contactFile, 'utf-8'));
                         contactData._deletedAt = new Date().toISOString();
                         contactData._delete = change._delete || entry?._delete || 'unknown';
                         const destPath = path.join(paths.deletedDir, path.basename(contactFile));
@@ -1090,7 +1154,7 @@ async function pushContacts(user: string, options: { yes: boolean; verbose: bool
                 }
             }
-            await sleep(700);  // 90 writes/min limit = ~700ms between ops
+            await sleep(1500);  // Google tightened limits - need ~1.5s between ops
         } catch (error: any) {
             const fileName = path.basename(change.filePath);
             const errorMsg = `${fileName}: ${error.message}`;
@@ -1104,6 +1168,26 @@ async function pushContacts(user: string, options: { yes: boolean; verbose: bool
                 continue;
             }
+            // Check for 404 - contact deleted on server, remove locally
+            if (error.message?.includes('404') || error.message?.includes('NOT_FOUND')) {
+                console.log(`    → Contact deleted on Google. Removing local copy.`);
+                // Move to deleted folder
+                if (fs.existsSync(change.filePath)) {
+                    const id = path.basename(change.filePath, '.json');
+                    if (!fs.existsSync(paths.deletedDir)) {
+                        fs.mkdirSync(paths.deletedDir, { recursive: true });
+                    }
+                    const destPath = path.join(paths.deletedDir, `${id}.json`);
+                    fs.renameSync(change.filePath, destPath);
+                }
+                // Remove from index
+                if (index.contacts[change.resourceName]) {
+                    delete index.contacts[change.resourceName];
+                    saveIndex(paths, index);
+                }
+                continue;
+            }
             // Get AI explanation if available and error is from API
             if (error instanceof ApiError && error.payload) {
                 if (isAIAvailable()) {
@@ -1169,7 +1253,7 @@ async function pushContacts(user: string, options: { yes: boolean; verbose: bool
             let email = '';
             if (nd.filePath && fs.existsSync(nd.filePath)) {
                 try {
-                    const contact = JSON.parse(fs.readFileSync(nd.filePath, 'utf-8'));
+                    const contact = parseJsonc(fs.readFileSync(nd.filePath, 'utf-8'));
                     email = contact.emailAddresses?.[0]?.value || '';
                 } catch { /* ignore */ }
             }

package/gfix.ts CHANGED Viewed

@@ -19,7 +19,7 @@ import { mergeContacts as mergeContactData, collectSourcePhotos, type MergeEntry
 function loadDeleteQueue(paths: UserPaths): DeleteQueue {
     if (fs.existsSync(paths.deleteQueueFile)) {
-        return JSON.parse(fs.readFileSync(paths.deleteQueueFile, 'utf-8'));
+        return parseJsonc(fs.readFileSync(paths.deleteQueueFile, 'utf-8'));
     }
     return { updatedAt: '', entries: [] };
 }
@@ -323,7 +323,7 @@ async function runBirthdayExtract(user: string, mode: 'inspect' | 'apply'): Prom
     for (const file of files) {
         const filePath = path.join(paths.contactsDir, file);
-        const contact = JSON.parse(fs.readFileSync(filePath, 'utf-8')) as GooglePerson;
+        const contact = parseJsonc(fs.readFileSync(filePath, 'utf-8')) as GooglePerson;
         if (!contact.birthdays?.length) continue;
@@ -413,7 +413,7 @@ async function runFileAsFix(user: string, mode: 'inspect' | 'apply'): Promise<vo
     for (const file of files) {
         const filePath = path.join(paths.contactsDir, file);
-        const contact = JSON.parse(fs.readFileSync(filePath, 'utf-8')) as GooglePerson;
+        const contact = parseJsonc(fs.readFileSync(filePath, 'utf-8')) as GooglePerson;
         const name = contact.names?.[0];
         const givenName = name?.givenName || '';
@@ -1132,7 +1132,7 @@ async function runNamesFix(user: string, mode: 'inspect' | 'apply'): Promise<voi
                 const dst = path.join(paths.toDeleteDir, entry.file);
                 fs.renameSync(src, dst);
             }
-            const existing = fs.existsSync(emailOnlyFile) ? JSON.parse(fs.readFileSync(emailOnlyFile, 'utf-8')) : [];
+            const existing = fs.existsSync(emailOnlyFile) ? parseJsonc(fs.readFileSync(emailOnlyFile, 'utf-8')) : [];
             existing.push(...emailOnly.map(e => ({ file: e.file, resourceName: e.resourceName, email: e.email, movedAt: new Date().toISOString() })));
             fs.writeFileSync(emailOnlyFile, JSON.stringify(existing, null, 2));
         }
@@ -1143,7 +1143,7 @@ async function runNamesFix(user: string, mode: 'inspect' | 'apply'): Promise<voi
                 const dst = path.join(paths.toDeleteDir, entry.file);
                 fs.renameSync(src, dst);
             }
-            const existing = fs.existsSync(phoneOnlyFile) ? JSON.parse(fs.readFileSync(phoneOnlyFile, 'utf-8')) : [];
+            const existing = fs.existsSync(phoneOnlyFile) ? parseJsonc(fs.readFileSync(phoneOnlyFile, 'utf-8')) : [];
             existing.push(...phoneOnly.map(e => ({ file: e.file, resourceName: e.resourceName, phone: e.phone, movedAt: new Date().toISOString() })));
             fs.writeFileSync(phoneOnlyFile, JSON.stringify(existing, null, 2));
         }
@@ -1216,7 +1216,7 @@ async function runFix(user: string, mode: 'inspect' | 'apply'): Promise<void> {
     for (const file of files) {
         const filePath = path.join(paths.contactsDir, file);
-        const contact = JSON.parse(fs.readFileSync(filePath, 'utf-8')) as GooglePerson;
+        const contact = parseJsonc(fs.readFileSync(filePath, 'utf-8')) as GooglePerson;
         const changes = processContact(contact);
         if (changes.length > 0) {
@@ -1303,7 +1303,13 @@ async function runUndup(user: string): Promise<void> {
     for (const file of files) {
         const filePath = path.join(paths.contactsDir, file);
-        const contact = JSON.parse(fs.readFileSync(filePath, 'utf-8')) as GooglePerson;
+        let contact: GooglePerson;
+        try {
+            contact = parseJsonc(fs.readFileSync(filePath, 'utf-8'));
+        } catch (e: any) {
+            console.error(`[PARSE ERROR] ${file}: ${e.message}`);
+            continue;
+        }
         const name = contact.names?.[0];
         if (!name) continue;
@@ -1401,19 +1407,51 @@ async function runUndup(user: string): Promise<void> {
     console.log(`Then run: gfix merge -u ${user}`);
 }
+/** Check if contact has a non-default (custom) photo */
+function hasNonDefaultPhoto(contact: GooglePerson): boolean {
+    return contact.photos?.some(p => !p.default) || false;
+}
+/** Get non-default photo URL from contact */
+function getPhotoUrl(contact: GooglePerson): string {
+    const photo = contact.photos?.find(p => !p.default);
+    return photo?.url || '';
+}
+/** Choose best target from contacts - prefer one with custom photo */
+function chooseBestTarget(contacts: GooglePerson[]): { target: GooglePerson; sources: GooglePerson[] } {
+    // Sort: contacts with photos first
+    const sorted = [...contacts].sort((a, b) => {
+        const aHasPhoto = hasNonDefaultPhoto(a);
+        const bHasPhoto = hasNonDefaultPhoto(b);
+        if (aHasPhoto && !bHasPhoto) return -1;
+        if (!aHasPhoto && bHasPhoto) return 1;
+        return 0;
+    });
+    return { target: sorted[0], sources: sorted.slice(1) };
+}
+/** Check if two contacts have the same photo (by URL) */
+function haveSamePhoto(a: GooglePerson, b: GooglePerson): boolean {
+    const urlA = getPhotoUrl(a);
+    const urlB = getPhotoUrl(b);
+    if (!urlA || !urlB) return false;
+    return urlA === urlB;
+}
 /** Merge duplicate contacts locally (prepares for gcards push) */
 async function runMerge(user: string, limit: number): Promise<void> {
     const paths = getUserPaths(user);
     const mergerPath = path.join(paths.userDir, 'merger.json');
     const mergedPath = path.join(paths.userDir, 'merged.json');
-    const photosPath = path.join(paths.userDir, 'photos.json');
+    const photosPath = paths.photosFile;  // _photos.json
     if (!fs.existsSync(mergerPath)) {
         console.error(`No merger.json found. Run 'gfix undup -u ${user}' first.`);
         process.exit(1);
     }
-    let entries: MergeEntry[] = JSON.parse(fs.readFileSync(mergerPath, 'utf-8'));
+    let entries: MergeEntry[] = parseJsonc(fs.readFileSync(mergerPath, 'utf-8'));
     if (entries.length === 0) {
         console.log('No entries in merger.json');
@@ -1446,7 +1484,8 @@ async function runMerge(user: string, limit: number): Promise<void> {
     // Load existing files
     let savedPhotos: PhotoEntry[] = [];
     if (fs.existsSync(photosPath)) {
-        savedPhotos = JSON.parse(fs.readFileSync(photosPath, 'utf-8'));
+        const parsed = parseJsonc(fs.readFileSync(photosPath, 'utf-8'));
+        savedPhotos = Array.isArray(parsed) ? parsed : [];
     }
     const deleteQueue = loadDeleteQueue(paths);
@@ -1457,13 +1496,15 @@ async function runMerge(user: string, limit: number): Promise<void> {
         const content = fs.readFileSync(mergedPath, 'utf-8').trim();
         if (content) {
             try {
-                mergedEntries = JSON.parse(content);
+                const parsed = parseJsonc(content);
+                mergedEntries = Array.isArray(parsed) ? parsed : [];
             } catch { /* ignore parse errors, start fresh */ }
         }
     }
     let mergeSuccess = 0;
     let deleteSuccess = 0;
+    let samePhotoSkipped = 0;
     // Process merges - update local files only
     for (const entry of toMerge) {
@@ -1476,7 +1517,7 @@ async function runMerge(user: string, limit: number): Promise<void> {
                 const id = rn.replace('people/', '');
                 const filePath = path.join(paths.contactsDir, `${id}.json`);
                 if (fs.existsSync(filePath)) {
-                    contacts.push(JSON.parse(fs.readFileSync(filePath, 'utf-8')));
+                    contacts.push(parseJsonc(fs.readFileSync(filePath, 'utf-8')));
                 } else {
                     throw new Error(`Contact file not found: ${filePath}`);
                 }
@@ -1487,8 +1528,16 @@ async function runMerge(user: string, limit: number): Promise<void> {
                 continue;
             }
-            // Target is first, sources are rest
-            const [target, ...sources] = contacts;
+            // Check if all contacts have the same photo URL - if so, safe to merge
+            const photoUrls = contacts.map(c => getPhotoUrl(c)).filter(u => u);
+            const uniquePhotoUrls = [...new Set(photoUrls)];
+            if (uniquePhotoUrls.length === 1) {
+                console.log(`  Same photo URL detected - safe to merge`);
+                samePhotoSkipped++;
+            }
+            // Choose best target (one with photo preferred)
+            const { target, sources } = chooseBestTarget(contacts);
             // Collect photos from sources before marking for deletion
             const sourcePhotoUrls = collectSourcePhotos(sources);
@@ -1545,7 +1594,7 @@ async function runMerge(user: string, limit: number): Promise<void> {
             const id = rn.replace('people/', '');
             const filePath = path.join(paths.contactsDir, `${id}.json`);
             if (fs.existsSync(filePath)) {
-                const contact = JSON.parse(fs.readFileSync(filePath, 'utf-8')) as GooglePerson;
+                const contact = parseJsonc(fs.readFileSync(filePath, 'utf-8')) as GooglePerson;
                 const displayName = contact.names?.[0]?.displayName || entry.name;
                 deleteQueue.entries.push({
                     resourceName: rn,
@@ -1564,9 +1613,47 @@ async function runMerge(user: string, limit: number): Promise<void> {
         mergedEntries.push(entry);
     }
-    // Save photos.json
+    // Save photos (JSON data + HTML view)
     if (savedPhotos.length > 0) {
         fs.writeFileSync(photosPath, JSON.stringify(savedPhotos, null, 2));
+        // Generate HTML view
+        const htmlPath = paths.photosHtmlFile;
+        const html = `<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>Saved Photos from Merged Contacts</title>
+    <style>
+        body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; margin: 20px; }
+        h1 { color: #333; }
+        table { border-collapse: collapse; width: 100%; }
+        th, td { border: 1px solid #ddd; padding: 8px; text-align: left; vertical-align: middle; }
+        th { background: #f5f5f5; }
+        tr:hover { background: #f9f9f9; }
+        img { width: 100px; height: 100px; object-fit: cover; border-radius: 4px; margin: 2px; }
+        a { color: #1a73e8; text-decoration: none; }
+        a:hover { text-decoration: underline; }
+    </style>
+</head>
+<body>
+    <h1>Saved Photos from Merged Contacts (${savedPhotos.length})</h1>
+    <table>
+        <tr><th>Photos</th><th>Name</th></tr>
+${savedPhotos.map(entry => {
+    const id = entry.contactId.replace('people/', '');
+    const contactUrl = `https://contacts.google.com/person/${id}`;
+    const photoImgs = entry.photos.map(url => `<img src="${url}" alt="${entry.name}" loading="lazy">`).join('');
+    return `        <tr>
+            <td>${photoImgs || '(no photo)'}</td>
+            <td><a href="${contactUrl}" target="_blank">${entry.name}</a></td>
+        </tr>`;
+}).join('\n')}
+    </table>
+</body>
+</html>`;
+        fs.writeFileSync(htmlPath, html);
+        console.log(`\nSaved ${savedPhotos.length} photo entries to ${htmlPath}`);
     }
     // Save merged.json (history of processed entries)
@@ -1579,19 +1666,233 @@ async function runMerge(user: string, limit: number): Promise<void> {
     fs.writeFileSync(paths.indexFile, JSON.stringify(index, null, 2));
     // Remove processed entries from merger.json
-    const remainingEntries = JSON.parse(fs.readFileSync(mergerPath, 'utf-8')) as MergeEntry[];
+    const remainingEntries = parseJsonc(fs.readFileSync(mergerPath, 'utf-8')) as MergeEntry[];
     const processedNames = new Set(entries.map(e => e.name));
     const newMerger = remainingEntries.filter(e => !processedNames.has(e.name));
     fs.writeFileSync(mergerPath, JSON.stringify(newMerger, null, 2));
     console.log(`\n${'='.repeat(50)}`);
     console.log(`Summary:`);
-    console.log(`  Merged: ${mergeSuccess}`);
+    console.log(`  Merged: ${mergeSuccess}${samePhotoSkipped > 0 ? ` (${samePhotoSkipped} with same photo)` : ''}`);
     console.log(`  Marked for deletion: ${deleteSuccess}`);
     console.log(`  Remaining in merger.json: ${newMerger.length}`);
     console.log(`\nRun 'gcards push -u ${user}' to apply changes to Google.`);
 }
+// ============================================================
+// Photo Comparison Utilities
+// ============================================================
+/** Fetch image and compute a simple hash for comparison */
+async function fetchPhotoHash(url: string): Promise<string> {
+    try {
+        const response = await fetch(url);
+        if (!response.ok) return '';
+        const buffer = await response.arrayBuffer();
+        // Use a simple hash of the first 1KB + size for quick comparison
+        const bytes = new Uint8Array(buffer);
+        let hash = bytes.length;
+        const sampleSize = Math.min(1024, bytes.length);
+        for (let i = 0; i < sampleSize; i++) {
+            hash = ((hash << 5) - hash + bytes[i]) | 0;
+        }
+        return `${bytes.length}:${hash.toString(16)}`;
+    } catch {
+        return '';
+    }
+}
+/** Generate photos.html with contact photos for review */
+async function runPhotos(user: string): Promise<void> {
+    const paths = getUserPaths(user);
+    if (!fs.existsSync(paths.contactsDir)) {
+        console.error(`No contacts directory for user: ${user}`);
+        process.exit(1);
+    }
+    const files = fs.readdirSync(paths.contactsDir).filter(f => f.endsWith('.json'));
+    console.log(`\nScanning ${files.length} contacts for photos...\n`);
+    interface PhotoContact {
+        id: string;
+        displayName: string;
+        photoUrl: string;
+        resourceName: string;
+    }
+    const contacts: PhotoContact[] = [];
+    for (const file of files) {
+        const filePath = path.join(paths.contactsDir, file);
+        const contact = parseJsonc(fs.readFileSync(filePath, 'utf-8')) as GooglePerson;
+        const photoUrl = getPhotoUrl(contact);
+        if (!photoUrl) continue;
+        const displayName = contact.names?.[0]?.displayName ||
+                           contact.names?.[0]?.givenName ||
+                           'Unknown';
+        const id = contact.resourceName.replace('people/', '');
+        contacts.push({
+            id,
+            displayName,
+            photoUrl,
+            resourceName: contact.resourceName
+        });
+    }
+    // Sort by name
+    contacts.sort((a, b) => a.displayName.localeCompare(b.displayName));
+    console.log(`Found ${contacts.length} contacts with photos`);
+    // Generate HTML
+    const htmlPath = path.join(paths.userDir, 'photos.html');
+    const html = `<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>Contacts with Photos - ${user}</title>
+    <style>
+        body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; margin: 20px; }
+        h1 { color: #333; }
+        table { border-collapse: collapse; width: 100%; }
+        th, td { border: 1px solid #ddd; padding: 8px; text-align: left; vertical-align: middle; }
+        th { background: #f5f5f5; }
+        tr:hover { background: #f9f9f9; }
+        img { width: 100px; height: 100px; object-fit: cover; border-radius: 4px; }
+        a { color: #1a73e8; text-decoration: none; }
+        a:hover { text-decoration: underline; }
+        .id { font-size: 12px; color: #666; }
+    </style>
+</head>
+<body>
+    <h1>Contacts with Photos (${contacts.length})</h1>
+    <table>
+        <tr><th>Photo</th><th>Name</th></tr>
+${contacts.map(c => {
+    const contactUrl = `https://contacts.google.com/person/${c.id}`;
+    return `        <tr>
+            <td><img src="${c.photoUrl}" alt="${c.displayName}" loading="lazy"></td>
+            <td><a href="${contactUrl}" target="_blank">${c.displayName}</a><br><span class="id">${c.id}</span></td>
+        </tr>`;
+}).join('\n')}
+    </table>
+</body>
+</html>`;
+    fs.writeFileSync(htmlPath, html);
+    console.log(`\nGenerated: ${htmlPath}`);
+    console.log(`Open in browser to review contacts with photos.`);
+}
+/** Find contacts with same photo (by downloading and hashing) */
+async function runPhotoCompare(user: string): Promise<void> {
+    const paths = getUserPaths(user);
+    if (!fs.existsSync(paths.contactsDir)) {
+        console.error(`No contacts directory for user: ${user}`);
+        process.exit(1);
+    }
+    const files = fs.readdirSync(paths.contactsDir).filter(f => f.endsWith('.json'));
+    console.log(`\nScanning ${files.length} contacts for photo duplicates...\n`);
+    interface PhotoInfo {
+        id: string;
+        displayName: string;
+        photoUrl: string;
+        hash: string;
+    }
+    const photoInfos: PhotoInfo[] = [];
+    // First collect all contacts with photos
+    for (const file of files) {
+        const filePath = path.join(paths.contactsDir, file);
+        const contact = parseJsonc(fs.readFileSync(filePath, 'utf-8')) as GooglePerson;
+        const photoUrl = getPhotoUrl(contact);
+        if (!photoUrl) continue;
+        const displayName = contact.names?.[0]?.displayName || 'Unknown';
+        const id = contact.resourceName.replace('people/', '');
+        photoInfos.push({ id, displayName, photoUrl, hash: '' });
+    }
+    console.log(`Found ${photoInfos.length} contacts with photos`);
+    // Check for URL duplicates first (fast)
+    const byUrl = new Map<string, PhotoInfo[]>();
+    for (const info of photoInfos) {
+        const existing = byUrl.get(info.photoUrl) || [];
+        existing.push(info);
+        byUrl.set(info.photoUrl, existing);
+    }
+    const urlDuplicates = [...byUrl.entries()].filter(([, infos]) => infos.length > 1);
+    if (urlDuplicates.length > 0) {
+        console.log(`\nSame URL duplicates (${urlDuplicates.length} groups):`);
+        for (const [url, infos] of urlDuplicates) {
+            console.log(`  ${infos.map(i => i.displayName).join(', ')}`);
+        }
+    }
+    // Now fetch and hash unique URLs for pixel comparison
+    console.log(`\nFetching ${byUrl.size} unique photo URLs for hash comparison...`);
+    const hashByUrl = new Map<string, string>();
+    let fetched = 0;
+    for (const url of byUrl.keys()) {
+        const hash = await fetchPhotoHash(url);
+        hashByUrl.set(url, hash);
+        fetched++;
+        if (fetched % 10 === 0) {
+            process.stdout.write(`\r  Fetched ${fetched}/${byUrl.size}...`);
+        }
+    }
+    console.log(`\r  Fetched ${fetched}/${byUrl.size} - done`);
+    // Assign hashes
+    for (const info of photoInfos) {
+        info.hash = hashByUrl.get(info.photoUrl) || '';
+    }
+    // Group by hash (different URLs, same content)
+    const byHash = new Map<string, PhotoInfo[]>();
+    for (const info of photoInfos) {
+        if (!info.hash) continue;
+        const existing = byHash.get(info.hash) || [];
+        existing.push(info);
+        byHash.set(info.hash, existing);
+    }
+    // Find hash groups that span multiple URLs (actual pixel duplicates)
+    const hashDuplicates: { hash: string; infos: PhotoInfo[] }[] = [];
+    for (const [hash, infos] of byHash) {
+        const uniqueUrls = new Set(infos.map(i => i.photoUrl));
+        if (uniqueUrls.size > 1) {
+            hashDuplicates.push({ hash, infos });
+        }
+    }
+    if (hashDuplicates.length > 0) {
+        console.log(`\nSame content (different URLs) duplicates (${hashDuplicates.length} groups):`);
+        for (const { infos } of hashDuplicates) {
+            console.log(`  ${infos.map(i => i.displayName).join(', ')}`);
+        }
+    }
+    console.log(`\n${'='.repeat(50)}`);
+    console.log(`Summary:`);
+    console.log(`  Total contacts with photos: ${photoInfos.length}`);
+    console.log(`  Same URL duplicates: ${urlDuplicates.reduce((sum, [, infos]) => sum + infos.length - 1, 0)}`);
+    console.log(`  Same content duplicates: ${hashDuplicates.reduce((sum, { infos }) => sum + infos.length - 1, 0)}`);
+}
 // ============================================================
 // Export Feature - Transfer contacts between users
 // ============================================================
@@ -1612,7 +1913,7 @@ function findContactById(paths: UserPaths, id: string): { contact: GooglePerson;
     const contactPath = path.join(paths.contactsDir, `${cleanId}.json`);
     if (fs.existsSync(contactPath)) {
         return {
-            contact: JSON.parse(fs.readFileSync(contactPath, 'utf-8')),
+            contact: parseJsonc(fs.readFileSync(contactPath, 'utf-8')),
             filePath: contactPath,
             source: 'contacts'
         };
@@ -1622,7 +1923,7 @@ function findContactById(paths: UserPaths, id: string): { contact: GooglePerson;
     const deletedPath = path.join(paths.deletedDir, `${cleanId}.json`);
     if (fs.existsSync(deletedPath)) {
         return {
-            contact: JSON.parse(fs.readFileSync(deletedPath, 'utf-8')),
+            contact: parseJsonc(fs.readFileSync(deletedPath, 'utf-8')),
             filePath: deletedPath,
             source: 'deleted'
         };
@@ -1651,7 +1952,7 @@ function searchContacts(paths: UserPaths, pattern: string): ContactMatch[] {
     if (fs.existsSync(paths.contactsDir)) {
         for (const file of fs.readdirSync(paths.contactsDir).filter(f => f.endsWith('.json'))) {
             const filePath = path.join(paths.contactsDir, file);
-            const contact = JSON.parse(fs.readFileSync(filePath, 'utf-8')) as GooglePerson;
+            const contact = parseJsonc(fs.readFileSync(filePath, 'utf-8')) as GooglePerson;
             if (matchesContact(contact, regex)) {
                 matches.push({
                     id: file.replace(/\.json$/, ''),
@@ -1668,7 +1969,7 @@ function searchContacts(paths: UserPaths, pattern: string): ContactMatch[] {
     if (fs.existsSync(paths.deletedDir)) {
         for (const file of fs.readdirSync(paths.deletedDir).filter(f => f.endsWith('.json'))) {
             const filePath = path.join(paths.deletedDir, file);
-            const contact = JSON.parse(fs.readFileSync(filePath, 'utf-8')) as GooglePerson;
+            const contact = parseJsonc(fs.readFileSync(filePath, 'utf-8')) as GooglePerson;
             if (matchesContact(contact, regex)) {
                 matches.push({
                     id: file.replace(/\.json$/, ''),
@@ -1912,7 +2213,7 @@ async function runReset(user: string): Promise<void> {
     // Clear from index.json
     if (fs.existsSync(paths.indexFile)) {
-        const index = JSON.parse(fs.readFileSync(paths.indexFile, 'utf-8'));
+        const index = parseJsonc(fs.readFileSync(paths.indexFile, 'utf-8'));
         for (const entry of Object.values(index.contacts) as any[]) {
             if (entry._delete) {
                 delete entry._delete;
@@ -1928,7 +2229,7 @@ async function runReset(user: string): Promise<void> {
         for (const file of files) {
             const filePath = path.join(paths.contactsDir, file);
             const stat = fs.statSync(filePath);
-            const content = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+            const content = parseJsonc(fs.readFileSync(filePath, 'utf-8'));
             if (content._delete || content._deleted) {
                 delete content._delete;
                 delete content._deleted;
@@ -1942,7 +2243,7 @@ async function runReset(user: string): Promise<void> {
     // Clear _delete.json queue
     if (fs.existsSync(paths.deleteQueueFile)) {
-        const queue = JSON.parse(fs.readFileSync(paths.deleteQueueFile, 'utf-8'));
+        const queue = parseJsonc(fs.readFileSync(paths.deleteQueueFile, 'utf-8'));
         queueCleared = queue.entries?.length || 0;
         fs.unlinkSync(paths.deleteQueueFile);
     }
@@ -1981,7 +2282,9 @@ Commands:
     names       Parse givenName into first/middle/last, clean fileAs, remove dup phones/emails
     problems    Process edited problems.txt (apply fixes or deletions)
     undup       Find duplicate contacts (same name + overlapping email) -> merger.json
-    merge       Merge duplicates locally (then use gcards push)
+    merge       Merge duplicates locally (prefers contacts with photos)
+    photos      Generate photos.html with 100x100 photos and contact links
+    photocompare Find contacts with same photo (by URL or content hash)
     reset       Clear all _delete flags from index.json
     export      Transfer contact(s) to another user's _add directory
@@ -2017,9 +2320,15 @@ Processing problem contacts (from gfix names):
 Duplicate detection and merge:
   - gfix undup -u bob              # Find duplicates -> merger.json
   - Edit merger.json (remove false positives, add "_delete": true for spam)
-  - gfix merge -u bob              # Merge locally (updates files, marks for deletion)
+  - gfix merge -u bob              # Merge locally (prefers contacts with photos)
   - gcards push -u bob             # Push changes to Google
   - gcards sync -u bob --full      # Resync to get updated contacts
+  Note: merge prefers contacts with photos. If all have same photo URL, safe to merge.
+Photo review and comparison:
+  - gfix photos -u bob             # Generate photos.html for visual review
+  - gfix photocompare -u bob       # Find duplicates by URL and content hash
+  Output: photos.html with 100x100 photos, names, and links to Google Contacts
 Export contacts to another user:
   - gfix export -u bob -to alice "John*"         # Export contacts matching "John*" to alice
@@ -2128,6 +2437,10 @@ async function main(): Promise<void> {
         await runUndup(resolvedUser);
     } else if (command === 'merge') {
         await runMerge(resolvedUser, processLimit);
+    } else if (command === 'photos') {
+        await runPhotos(resolvedUser);
+    } else if (command === 'photocompare') {
+        await runPhotoCompare(resolvedUser);
     } else if (command === 'reset') {
         await runReset(resolvedUser);
     } else if (command === 'problems') {

package/glib/gctypes.ts CHANGED Viewed

@@ -99,7 +99,8 @@ export interface UserPaths {
     indexFile: string;
     deletedFile: string;       /** Deleted contacts index (deleted.json) */
     deleteQueueFile: string;   /** Pending deletions (_delete.json) */
-    photosFile: string;        /** Photos from deleted contacts (photos.json) */
+    photosFile: string;        /** Photos data store (_photos.json) */
+    photosHtmlFile: string;    /** Photos HTML view (photos.html) */
     statusFile: string;
     syncTokenFile: string;
     tokenFile: string;

package/glib/gmerge.ts CHANGED Viewed

@@ -261,8 +261,8 @@ export function collectSourcePhotos(sources: GooglePerson[]): string[] {
     const urls: string[] = [];
     for (const source of sources) {
         for (const photo of source.photos || []) {
-            // Only collect custom photos (default: false means custom)
-            if (photo.url && photo.default === false) {
+            // Only collect custom photos (!default means custom - undefined or false)
+            if (photo.url && !photo.default) {
                 urls.push(photo.url);
             }
         }

package/glib/gutils.ts CHANGED Viewed

@@ -64,7 +64,8 @@ export function getUserPaths(user: string): UserPaths {
         indexFile: path.join(userDir, 'index.json'),
         deletedFile: path.join(userDir, 'deleted.json'),
         deleteQueueFile: path.join(userDir, '_delete.json'),
-        photosFile: path.join(userDir, 'photos.json'),
+        photosFile: path.join(userDir, '_photos.json'),
+        photosHtmlFile: path.join(userDir, 'photos.html'),
         statusFile: path.join(userDir, 'status.json'),
         syncTokenFile: path.join(userDir, 'sync-token.json'),
         tokenFile: path.join(userDir, 'token.json'),

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/gcards",
-  "version": "0.1.20",
+  "version": "0.1.22",
   "description": "Google Contacts cleanup and management tool",
   "type": "module",
   "main": "gcards.ts",