buddy-workbench 0.1.13 → 0.1.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buddy-workbench",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "private": false,
   "type": "module",
   "bin": {
@@ -18,7 +18,8 @@
     "dev": "node --watch server.js",
     "build": "npm --prefix ui run build",
     "dev:ui": "npm --prefix ui run dev",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "version": "node -e \"const v=process.env.npm_package_version; const fs=require('fs'); ['ui/package.json', 'ui/package-lock.json'].forEach(p=>{if(fs.existsSync(p)){const j=JSON.parse(fs.readFileSync(p)); j.version=v; if(j.packages&&j.packages['']){j.packages[''].version=v;} fs.writeFileSync(p, JSON.stringify(j,null,2)+'\\n');}});\" && git add ui/package.json ui/package-lock.json"
   },
   "dependencies": {
     "axios": "^1.7.9",

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/routes/launchers.js

@@ -1,8 +1,8 @@
 import { Router } from 'express';
 import { listLaunchers, saveLaunchers } from '../repositories/launchers.js';
-import { runScript, runningErrorCounts, runningScripts, scriptErrorLogs, scriptLogs, stopScript } from '../services/process-manager.js';
+import { clearScriptLogs, runScript, runningErrorCounts, runningScripts, scriptErrorLogs, scriptLogs, stopScript } from '../services/process-manager.js';
 import { readPackageScripts } from '../services/package-scripts.js';
-import { currentGitBranch } from '../services/git.js';
+import { currentGitBranch, getGitRemoteUrl, toWebRepoUrl } from '../services/git.js';
 
 const router = Router();
 function validLauncher(body) {
@@ -17,7 +17,18 @@ const invalid = (res) => res.status(400).json({ error: 'Name, project folder, an
 
 router.get('/', async (_req, res) => {
   const launchers = listLaunchers();
-  const items = await Promise.all(launchers.map(async (launcher) => ({ ...launcher, packageScriptCount: readPackageScripts(launcher.folder).length, branch: await currentGitBranch(launcher.folder) })));
+  const items = await Promise.all(launchers.map(async (launcher) => {
+    const [branch, remoteUrl] = await Promise.all([
+      currentGitBranch(launcher.folder),
+      getGitRemoteUrl(launcher.folder)
+    ]);
+    return {
+      ...launcher,
+      packageScriptCount: readPackageScripts(launcher.folder).length,
+      branch,
+      repoUrl: toWebRepoUrl(remoteUrl)
+    };
+  }));
   res.json(items);
 });
 router.post('/', (req, res) => { const config = validLauncher(req.body); if (!config) return invalid(res); const launcher = { id: crypto.randomUUID(), ...config }; const launchers = listLaunchers(); saveLaunchers([...launchers, launcher]); res.status(201).json(launcher); });
@@ -39,8 +50,10 @@ router.post('/:id/install/run', (req, res) => { const launcher = listLaunchers()
 router.post('/:id/package-scripts/:scriptName/run', (req, res) => { const launcher = listLaunchers().find((item) => item.id === req.params.id); if (!launcher) return res.status(404).json({ error: 'Configuration not found.' }); const script = readPackageScripts(launcher.folder).find((item) => item.name === req.params.scriptName); if (!script) return res.status(404).json({ error: 'Package script not found.' }); try { runScript(launcher, { ...script, command: `${launcher.executor} run ${script.name}` }); res.json({ ok: true }); } catch (error) { res.status(error.message.includes('already') ? 409 : 400).json({ error: error.message }); } });
 router.get('/:id/package-scripts/:scriptName/logs', (req, res) => { const script = readPackageScripts(listLaunchers().find((item) => item.id === req.params.id)?.folder || '').find((item) => item.name === req.params.scriptName); if (!script) return res.status(404).json({ error: 'Package script not found.' }); res.json({ log: scriptLogs(req.params.id, script.id) }); });
 router.get('/:id/package-scripts/:scriptName/logs/error', (req, res) => { const script = readPackageScripts(listLaunchers().find((item) => item.id === req.params.id)?.folder || '').find((item) => item.name === req.params.scriptName); if (!script) return res.status(404).json({ error: 'Package script not found.' }); res.json({ log: scriptErrorLogs(req.params.id, script.id) }); });
+router.delete('/:id/package-scripts/:scriptName/logs', (req, res) => { const script = readPackageScripts(listLaunchers().find((item) => item.id === req.params.id)?.folder || '').find((item) => item.name === req.params.scriptName); if (!script) return res.status(404).json({ error: 'Package script not found.' }); clearScriptLogs(req.params.id, script.id); res.json({ ok: true }); });
 router.get('/:id/scripts/:scriptId/logs', (req, res) => res.json({ log: scriptLogs(req.params.id, req.params.scriptId) }));
 router.get('/:id/scripts/:scriptId/logs/error', (req, res) => res.json({ log: scriptErrorLogs(req.params.id, req.params.scriptId) }));
+router.delete('/:id/scripts/:scriptId/logs', (req, res) => { clearScriptLogs(req.params.id, req.params.scriptId); res.json({ ok: true }); });
 router.post('/:id/scripts/:scriptId/run', (req, res) => { const launcher = listLaunchers().find((item) => item.id === req.params.id); if (!launcher) return res.status(404).json({ error: 'Configuration not found.' }); const script = launcher.scripts.find((item) => item.id === req.params.scriptId); if (!script) return res.status(404).json({ error: 'Script not found.' }); try { runScript(launcher, script); res.json({ ok: true }); } catch (error) { res.status(error.message.includes('already') ? 409 : 400).json({ error: error.message }); } });
 router.post('/:id/scripts/:scriptId/stop', (req, res) => { try { stopScript(req.params.id, req.params.scriptId); res.json({ ok: true }); } catch (error) { res.status(404).json({ error: error.message }); } });
 

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/services/git.js

@@ -12,3 +12,79 @@ export async function currentGitBranch(folder) {
     return null;
   }
 }
+
+export async function getGitRemoteUrl(folder) {
+  if (!folder) return null;
+  try {
+    const { stdout } = await execFileAsync('git', ['config', '--get', 'remote.origin.url'], { cwd: folder, timeout: 1500 });
+    const url = stdout.trim();
+    if (url) return url;
+  } catch {}
+  try {
+    const { stdout } = await execFileAsync('git', ['remote', '-v'], { cwd: folder, timeout: 1500 });
+    const match = stdout.match(/\S+\s+(\S+)\s+\(fetch\)/);
+    if (match) return match[1].trim();
+  } catch {}
+  return null;
+}
+
+export function toWebRepoUrl(remoteUrl) {
+  if (!remoteUrl || typeof remoteUrl !== 'string') return null;
+  let raw = remoteUrl.trim();
+  if (!raw) return null;
+
+  // Remove trailing .git
+  raw = raw.replace(/\.git$/i, '');
+
+  // Handle SCP-like SSH syntax: git@host:owner/repo
+  const scpMatch = raw.match(/^([a-zA-Z0-9_.-]+@)?([^:]+):(.+)$/);
+  if (!raw.includes('://') && scpMatch) {
+    const host = scpMatch[2];
+    let path = scpMatch[3].replace(/^\/+/, '');
+
+    if (host.includes('bitbucket') && !host.includes('bitbucket.org')) {
+      const parts = path.split('/');
+      if (parts.length === 2 && parts[0] !== 'projects' && parts[0] !== 'users') {
+        const projKey = parts[0].startsWith('~') ? `users/${parts[0].slice(1)}` : `projects/${parts[0]}`;
+        path = `${projKey}/repos/${parts[1]}`;
+      } else if (parts.length === 3 && parts[0] === 'scm') {
+        const projKey = parts[1].startsWith('~') ? `users/${parts[1].slice(1)}` : `projects/${parts[1]}`;
+        path = `${projKey}/repos/${parts[2]}`;
+      }
+    }
+    return `https://${host}/${path}`;
+  }
+
+  // Handle URLs with protocols (ssh://, http://, https://)
+  try {
+    let urlStr = raw;
+    const isSshProto = urlStr.startsWith('ssh://');
+    if (isSshProto) {
+      urlStr = urlStr.replace(/^ssh:\/\//i, 'https://');
+    }
+    // Strip userinfo (e.g. git@ or user:pass@)
+    urlStr = urlStr.replace(/^(https?:\/\/)(([^/@]+)@)/i, '$1');
+
+    const urlObj = new URL(urlStr);
+    const host = urlObj.hostname;
+    let pathname = urlObj.pathname.replace(/^\/+/, '');
+
+    if (host.includes('bitbucket') && !host.includes('bitbucket.org')) {
+      const parts = pathname.split('/');
+      if (parts.length === 2 && parts[0] !== 'projects' && parts[0] !== 'users') {
+        const projKey = parts[0].startsWith('~') ? `users/${parts[0].slice(1)}` : `projects/${parts[0]}`;
+        pathname = `${projKey}/repos/${parts[1]}`;
+      } else if (parts.length === 3 && parts[0] === 'scm') {
+        const projKey = parts[1].startsWith('~') ? `users/${parts[1].slice(1)}` : `projects/${parts[1]}`;
+        pathname = `${projKey}/repos/${parts[2]}`;
+      }
+    }
+
+    const protocol = raw.startsWith('http://') ? 'http:' : 'https:';
+    const portStr = (urlObj.port && !isSshProto) ? `:${urlObj.port}` : '';
+    return `${protocol}//${host}${portStr}/${pathname}`;
+  } catch {
+    return null;
+  }
+}
+

package/server/services/process-manager.js

@@ -60,7 +60,6 @@ export function countErrorBlocks(text, isStderr = false) {
     }
 
     const isErrorLine =
-      isStderr ||
       isNewHeader ||
       /\b(error|failed|fatal|exception)\b/i.test(cleanLine) ||
       /^npm ERR!/i.test(cleanLine) ||
@@ -83,8 +82,11 @@ export function countErrorBlocks(text, isStderr = false) {
 const appendLog = (key, type, chunk) => {
   const current = logs.get(key) || { output: '', error: '', errorCount: 0 };
   const str = String(chunk || '');
-  current[type] = `${current[type]}${str}`.split(/\r?\n/).slice(-1000).join('\n');
-  current.errorCount = countErrorBlocks(current.error, true) + countErrorBlocks(current.output, false);
+  if (type === 'error' || type === 'stderr') {
+    current.error = `${current.error}${str}`.split(/\r?\n/).slice(-1000).join('\n');
+  }
+  current.output = `${current.output}${str}`.split(/\r?\n/).slice(-1000).join('\n');
+  current.errorCount = countErrorBlocks(current.output, false);
   logs.set(key, current);
 };
 
@@ -98,6 +100,7 @@ export function runningErrorCounts() {
 }
 export function scriptLogs(launcherId, scriptId) { return logs.get(keyFor(launcherId, scriptId))?.output || ''; }
 export function scriptErrorLogs(launcherId, scriptId) { return logs.get(keyFor(launcherId, scriptId))?.error || ''; }
+export function clearScriptLogs(launcherId, scriptId) { logs.set(keyFor(launcherId, scriptId), { output: '', error: '', errorCount: 0 }); }
 
 async function listeningProcesses() {
   if (process.platform === 'win32') return [];

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({