buddy-workbench 0.1.13 → 0.1.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buddy-workbench",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "private": false,
   "type": "module",
   "bin": {

package/server/routes/bookmark-sync.js

@@ -0,0 +1,42 @@
+import { Router } from 'express';
+import {
+  getBookmarkSyncStatus,
+  previewSync,
+  performSync
+} from '../services/bookmark-sync.js';
+
+const router = Router();
+
+// Get status of Chrome & Edge bookmark files & processes
+router.get('/status', (req, res, next) => {
+  try {
+    const status = getBookmarkSyncStatus();
+    res.json(status);
+  } catch (error) {
+    next(error);
+  }
+});
+
+// Preview sync changes
+router.get('/preview', (req, res, next) => {
+  try {
+    const mode = req.query.mode || 'two-way';
+    const preview = previewSync(mode);
+    res.json(preview);
+  } catch (error) {
+    next(error);
+  }
+});
+
+// Perform actual sync
+router.post('/sync', (req, res, next) => {
+  try {
+    const mode = req.body?.mode || 'two-way';
+    const result = performSync(mode);
+    res.json(result);
+  } catch (error) {
+    next(error);
+  }
+});
+
+export default router;

package/server/services/bookmark-sync.js

@@ -0,0 +1,435 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import crypto from 'node:crypto';
+import { execSync } from 'node:child_process';
+
+/**
+ * Resolves standard bookmark file paths for Chrome and Edge based on OS.
+ */
+export function getBrowserBookmarkPaths() {
+  const home = os.homedir();
+  const platform = os.platform();
+
+  let chromePath = '';
+  let edgePath = '';
+
+  if (platform === 'darwin') {
+    chromePath = path.join(home, 'Library', 'Application Support', 'Google', 'Chrome', 'Default', 'Bookmarks');
+    edgePath = path.join(home, 'Library', 'Application Support', 'Microsoft Edge', 'Default', 'Bookmarks');
+  } else if (platform === 'win32') {
+    const localAppData = process.env.LOCALAPPDATA || path.join(home, 'AppData', 'Local');
+    chromePath = path.join(localAppData, 'Google', 'Chrome', 'User Data', 'Default', 'Bookmarks');
+    edgePath = path.join(localAppData, 'Microsoft', 'Edge', 'User Data', 'Default', 'Bookmarks');
+  } else {
+    chromePath = path.join(home, '.config', 'google-chrome', 'Default', 'Bookmarks');
+    edgePath = path.join(home, '.config', 'microsoft-edge', 'Default', 'Bookmarks');
+  }
+
+  return { chromePath, edgePath };
+}
+
+/**
+ * Checks if a browser process is currently running.
+ */
+export function checkBrowserRunning(browserName) {
+  try {
+    const processPattern = browserName === 'chrome' ? 'Google Chrome' : 'Microsoft Edge';
+    const output = execSync(`pgrep -f "${processPattern}"`, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    return output.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Reads and parses a Chromium bookmark file.
+ */
+export function readBookmarkFile(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    return JSON.parse(content);
+  } catch (error) {
+    throw new Error(`Failed to parse bookmark file at ${filePath}: ${error.message}`);
+  }
+}
+
+/**
+ * Extracts all URLs from a bookmark tree or roots object into a Map keyed by normalized URL.
+ */
+export function getAllUrls(node, urlMap = new Map()) {
+  if (!node) return urlMap;
+  if (node.type === 'url' && node.url) {
+    const normalizedUrl = normalizeUrl(node.url);
+    if (!urlMap.has(normalizedUrl)) {
+      urlMap.set(normalizedUrl, node);
+    }
+  }
+  if (Array.isArray(node.children)) {
+    for (const child of node.children) {
+      getAllUrls(child, urlMap);
+    }
+  } else if (typeof node === 'object') {
+    for (const key of Object.keys(node)) {
+      if (typeof node[key] === 'object' && node[key] !== null) {
+        getAllUrls(node[key], urlMap);
+      }
+    }
+  }
+  return urlMap;
+}
+
+/**
+ * Standardizes URL for comparison (removes trailing slash, case-insensitive protocol/domain).
+ */
+function normalizeUrl(rawUrl) {
+  try {
+    const parsed = new URL(rawUrl);
+    parsed.hash = '';
+    let href = parsed.href;
+    if (href.endsWith('/')) href = href.slice(0, -1);
+    return href.toLowerCase();
+  } catch {
+    return (rawUrl || '').trim().toLowerCase().replace(/\/$/, '');
+  }
+}
+
+/**
+ * Finds maximum numeric ID used in a bookmark tree.
+ */
+function getMaxId(node) {
+  let max = 0;
+  if (!node) return max;
+  const numericId = parseInt(node.id, 10);
+  if (!isNaN(numericId) && numericId > max) {
+    max = numericId;
+  }
+  if (Array.isArray(node.children)) {
+    for (const child of node.children) {
+      const childMax = getMaxId(child);
+      if (childMax > max) max = childMax;
+    }
+  } else if (typeof node === 'object') {
+    for (const key of Object.keys(node)) {
+      if (typeof node[key] === 'object' && node[key] !== null) {
+        const keyMax = getMaxId(node[key]);
+        if (keyMax > max) max = keyMax;
+      }
+    }
+  }
+  return max;
+}
+
+/**
+ * Collects list of all bookmark items from a node or roots object with their folder hierarchy path.
+ */
+export function extractBookmarksList(rootContainer, folderPath = []) {
+  let list = [];
+  if (!rootContainer) return list;
+
+  if (Array.isArray(rootContainer.children)) {
+    for (const child of rootContainer.children) {
+      if (child.type === 'folder') {
+        const currentPath = [...folderPath, child.name];
+        list = list.concat(extractBookmarksList(child, currentPath));
+      } else if (child.type === 'url' && child.url) {
+        list.push({
+          name: child.name || 'Untitled',
+          url: child.url,
+          folderPath: [...folderPath]
+        });
+      }
+    }
+  } else if (typeof rootContainer === 'object') {
+    for (const key of Object.keys(rootContainer)) {
+      if (typeof rootContainer[key] === 'object' && rootContainer[key] !== null) {
+        const rootFolder = rootContainer[key];
+        const initialPath = rootFolder.name ? [...folderPath] : folderPath;
+        list = list.concat(extractBookmarksList(rootFolder, initialPath));
+      }
+    }
+  }
+
+  return list;
+}
+
+/**
+ * Ensures target folder hierarchy exists in rootNode, returning the destination folder node.
+ */
+function ensureFolderPath(rootNode, folderPath, maxIdRef) {
+  let current = rootNode;
+  if (!current.children) current.children = [];
+
+  for (const folderName of folderPath) {
+    let childFolder = current.children.find(c => c.type === 'folder' && c.name === folderName);
+    if (!childFolder) {
+      maxIdRef.current += 1;
+      childFolder = {
+        children: [],
+        date_added: String(Date.now() * 1000),
+        date_modified: String(Date.now() * 1000),
+        guid: crypto.randomUUID(),
+        id: String(maxIdRef.current),
+        name: folderName,
+        type: 'folder'
+      };
+      current.children.push(childFolder);
+    }
+    current = childFolder;
+    if (!current.children) current.children = [];
+  }
+  return current;
+}
+
+/**
+ * Merges source items into target Chromium bookmark JSON structure.
+ * Returns { updatedJson, addedItems }
+ */
+export function mergeBookmarksIntoTree(targetJson, sourceItems) {
+  if (!targetJson || !targetJson.roots) {
+    // If target JSON doesn't exist or is invalid, build a fresh Chromium roots structure
+    targetJson = {
+      checksum: '',
+      roots: {
+        bookmark_bar: {
+          children: [],
+          date_added: String(Date.now() * 1000),
+          date_modified: String(Date.now() * 1000),
+          guid: crypto.randomUUID(),
+          id: '1',
+          name: '书签栏',
+          type: 'folder'
+        },
+        other: {
+          children: [],
+          date_added: String(Date.now() * 1000),
+          date_modified: String(Date.now() * 1000),
+          guid: crypto.randomUUID(),
+          id: '2',
+          name: '其他书签',
+          type: 'folder'
+        },
+        synced: {
+          children: [],
+          date_added: String(Date.now() * 1000),
+          date_modified: String(Date.now() * 1000),
+          guid: crypto.randomUUID(),
+          id: '3',
+          name: '移动设备书签',
+          type: 'folder'
+        }
+      },
+      version: 1
+    };
+  }
+
+  if (!targetJson.roots.bookmark_bar) {
+    targetJson.roots.bookmark_bar = {
+      children: [],
+      date_added: String(Date.now() * 1000),
+      date_modified: String(Date.now() * 1000),
+      guid: crypto.randomUUID(),
+      id: '1',
+      name: '书签栏',
+      type: 'folder'
+    };
+  }
+
+  // Get existing URLs across the entire target tree
+  const existingUrlMap = getAllUrls(targetJson.roots);
+
+  const maxIdRef = { current: getMaxId(targetJson.roots) };
+  const addedItems = [];
+
+  for (const item of sourceItems) {
+    const normUrl = normalizeUrl(item.url);
+    if (existingUrlMap.has(normUrl)) {
+      continue; // Skip existing bookmark
+    }
+
+    // Destination folder under bookmark_bar
+    const destFolder = ensureFolderPath(targetJson.roots.bookmark_bar, item.folderPath, maxIdRef);
+
+    maxIdRef.current += 1;
+    const newBookmarkNode = {
+      date_added: String(Date.now() * 1000),
+      guid: crypto.randomUUID(),
+      id: String(maxIdRef.current),
+      name: item.name,
+      type: 'url',
+      url: item.url
+    };
+
+    destFolder.children.push(newBookmarkNode);
+    existingUrlMap.set(normUrl, newBookmarkNode);
+    addedItems.push({
+      name: item.name,
+      url: item.url,
+      folderPath: item.folderPath.join(' / ') || '书签栏'
+    });
+  }
+
+  return { updatedJson: targetJson, addedItems };
+}
+
+/**
+ * Gets overview status of Chrome & Edge bookmarks.
+ */
+export function getBookmarkSyncStatus() {
+  const { chromePath, edgePath } = getBrowserBookmarkPaths();
+
+  const chromeExists = fs.existsSync(chromePath);
+  const edgeExists = fs.existsSync(edgePath);
+
+  const chromeRunning = checkBrowserRunning('chrome');
+  const edgeRunning = checkBrowserRunning('edge');
+
+  let chromeCount = 0;
+  let edgeCount = 0;
+
+  if (chromeExists) {
+    const chromeJson = readBookmarkFile(chromePath);
+    if (chromeJson && chromeJson.roots) {
+      const urls = getAllUrls(chromeJson.roots);
+      chromeCount = urls.size;
+    }
+  }
+
+  if (edgeExists) {
+    const edgeJson = readBookmarkFile(edgePath);
+    if (edgeJson && edgeJson.roots) {
+      const urls = getAllUrls(edgeJson.roots);
+      edgeCount = urls.size;
+    }
+  }
+
+  return {
+    chrome: {
+      path: chromePath,
+      exists: chromeExists,
+      running: chromeRunning,
+      count: chromeCount
+    },
+    edge: {
+      path: edgePath,
+      exists: edgeExists,
+      running: edgeRunning,
+      count: edgeCount
+    }
+  };
+}
+
+/**
+ * Previews what items would be added in sync.
+ */
+export function previewSync(mode = 'two-way') {
+  const { chromePath, edgePath } = getBrowserBookmarkPaths();
+  const chromeJson = readBookmarkFile(chromePath);
+  const edgeJson = readBookmarkFile(edgePath);
+
+  if (!chromeJson && !edgeJson) {
+    throw new Error('Neither Chrome nor Edge bookmark files were found.');
+  }
+
+  const chromeItems = chromeJson && chromeJson.roots ? extractBookmarksList(chromeJson.roots) : [];
+  const edgeItems = edgeJson && edgeJson.roots ? extractBookmarksList(edgeJson.roots) : [];
+
+  let toAddEdge = [];
+  let toAddChrome = [];
+
+  if (mode === 'two-way' || mode === 'chrome-to-edge') {
+    const baseEdgeJson = edgeJson || null;
+    const { addedItems } = mergeBookmarksIntoTree(baseEdgeJson ? structuredClone(baseEdgeJson) : null, chromeItems);
+    toAddEdge = addedItems;
+  }
+
+  if (mode === 'two-way' || mode === 'edge-to-chrome') {
+    const baseChromeJson = chromeJson || null;
+    const { addedItems } = mergeBookmarksIntoTree(baseChromeJson ? structuredClone(baseChromeJson) : null, edgeItems);
+    toAddChrome = addedItems;
+  }
+
+  return {
+    mode,
+    toAddEdge,
+    toAddChrome
+  };
+}
+
+/**
+ * Performs actual sync and creates backup files.
+ */
+export function performSync(mode = 'two-way') {
+  const { chromePath, edgePath } = getBrowserBookmarkPaths();
+  const chromeJson = readBookmarkFile(chromePath);
+  const edgeJson = readBookmarkFile(edgePath);
+
+  if (!chromeJson && !edgeJson) {
+    throw new Error('Neither Chrome nor Edge bookmark files were found.');
+  }
+
+  const chromeItems = chromeJson && chromeJson.roots ? extractBookmarksList(chromeJson.roots) : [];
+  const edgeItems = edgeJson && edgeJson.roots ? extractBookmarksList(edgeJson.roots) : [];
+
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const backupsCreated = [];
+
+  let addedToEdge = [];
+  let addedToChrome = [];
+
+  // Sync Chrome -> Edge
+  if (mode === 'two-way' || mode === 'chrome-to-edge') {
+    const { updatedJson, addedItems } = mergeBookmarksIntoTree(edgeJson ? structuredClone(edgeJson) : null, chromeItems);
+    addedToEdge = addedItems;
+
+    if (addedItems.length > 0) {
+      if (fs.existsSync(edgePath)) {
+        const edgeBak = `${edgePath}.bak_${timestamp}`;
+        fs.copyFileSync(edgePath, edgeBak);
+        backupsCreated.push(edgeBak);
+      } else {
+        // Ensure directory exists if creating new edge file
+        const edgeDir = path.dirname(edgePath);
+        if (!fs.existsSync(edgeDir)) {
+          fs.mkdirSync(edgeDir, { recursive: true });
+        }
+      }
+
+      fs.writeFileSync(edgePath, JSON.stringify(updatedJson, null, 2), 'utf8');
+    }
+  }
+
+  // Sync Edge -> Chrome
+  if (mode === 'two-way' || mode === 'edge-to-chrome') {
+    const { updatedJson, addedItems } = mergeBookmarksIntoTree(chromeJson ? structuredClone(chromeJson) : null, edgeItems);
+    addedToChrome = addedItems;
+
+    if (addedItems.length > 0) {
+      if (fs.existsSync(chromePath)) {
+        const chromeBak = `${chromePath}.bak_${timestamp}`;
+        fs.copyFileSync(chromePath, chromeBak);
+        backupsCreated.push(chromeBak);
+      } else {
+        const chromeDir = path.dirname(chromePath);
+        if (!fs.existsSync(chromeDir)) {
+          fs.mkdirSync(chromeDir, { recursive: true });
+        }
+      }
+
+      fs.writeFileSync(chromePath, JSON.stringify(updatedJson, null, 2), 'utf8');
+    }
+  }
+
+  return {
+    success: true,
+    timestamp,
+    backupsCreated,
+    addedToEdgeCount: addedToEdge.length,
+    addedToChromeCount: addedToChrome.length,
+    addedToEdge,
+    addedToChrome
+  };
+}

package/server.js

@@ -18,6 +18,7 @@ import todoRoutes from './server/routes/todos.js';
 import staticPagesRoutes from './server/routes/static-pages.js';
 import errorRoutes from './server/routes/errors.js';
 import postmanRoutes from './server/routes/postman.js';
+import bookmarkSyncRoutes from './server/routes/bookmark-sync.js';
 import { addErrorRecord } from './server/repositories/errors.js';
 import { startClipboardCapture } from './server/services/clipboard-history.js';
 
@@ -71,6 +72,7 @@ app.use('/api/todos', todoRoutes);
 app.use('/api/static-pages', staticPagesRoutes);
 app.use('/api/errors', errorRoutes);
 app.use('/api/postman', postmanRoutes);
+app.use('/api/bookmark-sync', bookmarkSyncRoutes);
 
 app.use((err, req, res, _next) => {
   addErrorRecord({