buddy-workbench 0.1.9 → 0.1.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buddy-workbench",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "private": false,
   "type": "module",
   "bin": {
@@ -20,6 +20,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
+    "axios": "^1.7.9",
     "express": "^5.1.0"
   }
 }

package/server/config.js

@@ -7,6 +7,10 @@ export const paths = {
   portHistory: join(root, 'data', 'port-history.json'),
   groupTasks: join(root, 'data', 'group-tasks.json'),
   settings: join(root, 'data', 'settings.json'),
+  jiraFilters: join(root, 'data', 'jira-filters.json'),
+  todos: join(root, 'data', 'todos.json'),
+  staticPages: join(root, 'data', 'static-pages.json'),
+  errors: join(root, 'data', 'errors.json'),
   shutdownLog: join(root, 'data', 'shutdown.log'),
   clipboardDir: join(root, 'data', 'clipboard'),
   plugins: join(root, 'plugins'),

package/server/repositories/errors.js

@@ -0,0 +1,44 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import crypto from 'node:crypto';
+import { paths } from '../config.js';
+
+export function listErrors() {
+  try {
+    return existsSync(paths.errors) ? JSON.parse(readFileSync(paths.errors, 'utf8')) : [];
+  } catch {
+    return [];
+  }
+}
+
+export function saveErrors(errors) {
+  mkdirSync(dirname(paths.errors), { recursive: true });
+  const trimmed = Array.isArray(errors) ? errors.slice(-100) : [];
+  writeFileSync(paths.errors, JSON.stringify(trimmed, null, 2));
+}
+
+export function addErrorRecord({ source = 'System', message = '', details = '', level = 'error' }) {
+  if (!message && !details) return null;
+  const current = listErrors();
+  const record = {
+    id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    source: String(source || 'System').trim(),
+    level: ['fatal', 'warning', 'error'].includes(level) ? level : 'error',
+    message: String(message || '').trim() || 'Unspecified Error',
+    details: String(details || '').trim()
+  };
+  current.push(record);
+  saveErrors(current);
+  return record;
+}
+
+export function clearAllErrors() {
+  saveErrors([]);
+}
+
+export function deleteErrorRecord(id) {
+  const current = listErrors();
+  const filtered = current.filter((item) => item.id !== id);
+  saveErrors(filtered);
+}

package/server/repositories/jira-filters.js

@@ -0,0 +1,16 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { paths } from '../config.js';
+
+export function listJiraFilters() {
+  try {
+    return existsSync(paths.jiraFilters) ? JSON.parse(readFileSync(paths.jiraFilters, 'utf8')) : [];
+  } catch {
+    return [];
+  }
+}
+
+export function saveJiraFilters(filters) {
+  mkdirSync(dirname(paths.jiraFilters), { recursive: true });
+  writeFileSync(paths.jiraFilters, JSON.stringify(filters, null, 2));
+}

package/server/repositories/settings.js

@@ -11,6 +11,9 @@ export function settingsStatus() {
   const settings = readSettings();
   return {
     domain: typeof settings.domain === 'string' ? settings.domain : '',
+    jiraIssuePrefix: typeof settings.jiraIssuePrefix === 'string' ? settings.jiraIssuePrefix : '',
+    defaultEditor: typeof settings.defaultEditor === 'string' ? settings.defaultEditor : 'vscode',
+    defaultBrowser: typeof settings.defaultBrowser === 'string' ? settings.defaultBrowser : 'chrome',
     bitbucketTokenConfigured: Boolean(settings.bitbucketAccessToken),
     jiraTokenConfigured: Boolean(settings.jiraAccessToken),
     confluenceTokenConfigured: Boolean(settings.confluenceAccessToken),
@@ -27,6 +30,33 @@ export function saveDomain(domain) {
   return settingsStatus();
 }
 
+export function saveJiraIssuePrefix(jiraIssuePrefix) {
+  const settings = readSettings();
+  if (jiraIssuePrefix) settings.jiraIssuePrefix = jiraIssuePrefix;
+  else delete settings.jiraIssuePrefix;
+  mkdirSync(dirname(paths.settings), { recursive: true });
+  writeFileSync(paths.settings, JSON.stringify(settings, null, 2), { mode: 0o600 });
+  return settingsStatus();
+}
+
+export function saveDefaultEditor(defaultEditor) {
+  const settings = readSettings();
+  const valid = ['vscode', 'devin', 'idea'];
+  settings.defaultEditor = valid.includes(defaultEditor) ? defaultEditor : 'vscode';
+  mkdirSync(dirname(paths.settings), { recursive: true });
+  writeFileSync(paths.settings, JSON.stringify(settings, null, 2), { mode: 0o600 });
+  return settingsStatus();
+}
+
+export function saveDefaultBrowser(defaultBrowser) {
+  const settings = readSettings();
+  const valid = ['chrome', 'edge', 'safari'];
+  settings.defaultBrowser = valid.includes(defaultBrowser) ? defaultBrowser : 'chrome';
+  mkdirSync(dirname(paths.settings), { recursive: true });
+  writeFileSync(paths.settings, JSON.stringify(settings, null, 2), { mode: 0o600 });
+  return settingsStatus();
+}
+
 export function saveClipboardEnabled(enabled) {
   const settings = readSettings();
   settings.clipboardEnabled = Boolean(enabled);

package/server/repositories/static-pages.js

@@ -0,0 +1,29 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { paths } from '../config.js';
+
+function normalize(item, index) {
+  const id = item.id || `static-${index + 1}`;
+  return {
+    id,
+    name: item.name || `Page ${index + 1}`,
+    url: item.url || '',
+    icon: item.icon || 'GlobalOutlined'
+  };
+}
+
+export function listStaticPages() {
+  if (!existsSync(paths.staticPages)) return [];
+  try {
+    const raw = JSON.parse(readFileSync(paths.staticPages, 'utf8'));
+    if (!Array.isArray(raw)) return [];
+    return raw.map(normalize);
+  } catch {
+    return [];
+  }
+}
+
+export function saveStaticPages(pages) {
+  mkdirSync(dirname(paths.staticPages), { recursive: true });
+  writeFileSync(paths.staticPages, JSON.stringify(pages, null, 2));
+}

package/server/repositories/todos.js

@@ -0,0 +1,16 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { paths } from '../config.js';
+
+export function listTodos() {
+  try {
+    return existsSync(paths.todos) ? JSON.parse(readFileSync(paths.todos, 'utf8')) : [];
+  } catch {
+    return [];
+  }
+}
+
+export function saveTodos(todos) {
+  mkdirSync(dirname(paths.todos), { recursive: true });
+  writeFileSync(paths.todos, JSON.stringify(todos, null, 2));
+}

package/server/routes/clipboard.js

@@ -1,8 +1,9 @@
 import express, { Router } from 'express';
-import { clipboardDates, clipboardItems, clipboardOriginal, deleteClipboardItem, saveClipboardImage, clipboardImagePath } from '../services/clipboard-history.js';
+import { clipboardDates, clipboardItems, clipboardOriginal, deleteClipboardItem, saveClipboardImage, clipboardImagePath, allTaggedClipboardItems, updateClipboardItemTags } from '../services/clipboard-history.js';
 
 const router = Router();
 router.get('/', (req, res) => res.json({ dates: clipboardDates(), items: clipboardItems(req.query.date) }));
+router.get('/tagged', (_req, res) => res.json({ items: allTaggedClipboardItems() }));
 
 router.post('/image', express.raw({ type: 'image/*', limit: '10mb' }), (req, res) => {
   try {
@@ -10,7 +11,9 @@ router.post('/image', express.raw({ type: 'image/*', limit: '10mb' }), (req, res
     if (!buffer || buffer.length === 0) {
       return res.status(400).json({ error: 'Image body is empty.' });
     }
-    const item = saveClipboardImage(buffer);
+    const contentType = req.headers['content-type'] || 'image/png';
+    const ext = contentType.includes('jpeg') || contentType.includes('jpg') ? 'jpg' : 'png';
+    const item = saveClipboardImage(buffer, ext);
     res.json(item);
   } catch (error) {
     res.status(500).json({ error: error.message });
@@ -27,5 +30,11 @@ router.get('/image/:filename', (req, res) => {
 });
 
 router.get('/:date/:id', (req, res) => { const text = clipboardOriginal(req.params.date, req.params.id); if (text === null) return res.status(404).json({ error: 'Clipboard entry not found.' }); res.type('text/plain').send(text); });
+router.put('/:date/:id/tags', (req, res) => {
+  const { tags } = req.body || {};
+  const updated = updateClipboardItemTags(req.params.date, req.params.id, tags);
+  if (!updated) return res.status(404).json({ error: 'Clipboard entry not found.' });
+  res.json(updated);
+});
 router.delete('/:date/:id', (req, res) => { if (!deleteClipboardItem(req.params.date, req.params.id)) return res.status(404).json({ error: 'Clipboard entry not found.' }); res.status(204).end(); });
 export default router;

package/server/routes/errors.js

@@ -0,0 +1,31 @@
+import { Router } from 'express';
+import { addErrorRecord, clearAllErrors, deleteErrorRecord, listErrors } from '../repositories/errors.js';
+
+const router = Router();
+
+router.get('/', (_req, res) => {
+  const errors = listErrors();
+  // Return newest first
+  res.json([...errors].reverse());
+});
+
+router.post('/', (req, res) => {
+  const { source, message, details, level } = req.body || {};
+  if (!message && !details) {
+    return res.status(400).json({ error: 'Message or details is required.' });
+  }
+  const record = addErrorRecord({ source, message, details, level });
+  res.status(201).json(record);
+});
+
+router.delete('/', (_req, res) => {
+  clearAllErrors();
+  res.status(204).end();
+});
+
+router.delete('/:id', (req, res) => {
+  deleteErrorRecord(req.params.id);
+  res.status(204).end();
+});
+
+export default router;

package/server/routes/jira-filters.js

@@ -0,0 +1,161 @@
+import https from 'node:https';
+import axios from 'axios';
+import { Router } from 'express';
+import { readSettings } from '../repositories/settings.js';
+import { listJiraFilters, saveJiraFilters } from '../repositories/jira-filters.js';
+
+const router = Router();
+const httpsAgent = new https.Agent({ rejectUnauthorized: false });
+const httpClient = axios.create({
+  httpsAgent,
+  validateStatus: () => true
+});
+
+function getJiraHost() {
+  const settings = readSettings();
+  const domain = settings.domain || '';
+  if (!domain) return '';
+  const clean = domain.replace(/^https?:\/\//i, '').replace(/\/+$/, '');
+  if (clean.includes('jira') || clean.includes('.atlassian.net')) return clean;
+  return `jira.${clean}`;
+}
+
+function getPriorityRank(priority) {
+  if (!priority) return 0;
+  const name = (typeof priority === 'string' ? priority : priority.name || '').toLowerCase();
+  if (name.includes('blocker') || name.includes('highest') || name.includes('p0') || name.includes('urgent')) return 50;
+  if (name.includes('critical') || name.includes('high') || name.includes('p1')) return 40;
+  if (name.includes('major') || name.includes('medium') || name.includes('normal') || name.includes('p2')) return 30;
+  if (name.includes('minor') || name.includes('low') || name.includes('p3')) return 20;
+  if (name.includes('trivial') || name.includes('lowest') || name.includes('p4')) return 10;
+  
+  if (typeof priority === 'object' && priority.id && !isNaN(Number(priority.id))) {
+    return 100 - Number(priority.id);
+  }
+  return 0;
+}
+
+// List all filters
+router.get('/', (_req, res) => {
+  res.json(listJiraFilters());
+});
+
+// Create filter
+router.post('/', (req, res) => {
+  const { name, filterId } = req.body || {};
+  if (!name || typeof name !== 'string' || !name.trim()) {
+    return res.status(400).json({ error: 'Filter name is required.' });
+  }
+  if (!filterId || (typeof filterId !== 'string' && typeof filterId !== 'number') || !String(filterId).trim()) {
+    return res.status(400).json({ error: 'Filter ID is required.' });
+  }
+
+  const filters = listJiraFilters();
+  const newFilter = {
+    id: Date.now().toString(36) + Math.random().toString(36).slice(2, 6),
+    name: name.trim(),
+    filterId: String(filterId).trim(),
+    createdAt: new Date().toISOString()
+  };
+  filters.push(newFilter);
+  saveJiraFilters(filters);
+  res.status(201).json(newFilter);
+});
+
+// Update filter
+router.put('/:id', (req, res) => {
+  const { id } = req.params;
+  const { name, filterId } = req.body || {};
+  const filters = listJiraFilters();
+  const index = filters.findIndex((f) => f.id === id);
+  if (index === -1) {
+    return res.status(404).json({ error: 'Filter not found.' });
+  }
+
+  if (name !== undefined) {
+    if (typeof name !== 'string' || !name.trim()) {
+      return res.status(400).json({ error: 'Filter name cannot be empty.' });
+    }
+    filters[index].name = name.trim();
+  }
+
+  if (filterId !== undefined) {
+    if ((typeof filterId !== 'string' && typeof filterId !== 'number') || !String(filterId).trim()) {
+      return res.status(400).json({ error: 'Filter ID cannot be empty.' });
+    }
+    filters[index].filterId = String(filterId).trim();
+  }
+
+  filters[index].updatedAt = new Date().toISOString();
+  saveJiraFilters(filters);
+  res.json(filters[index]);
+});
+
+// Delete filter
+router.delete('/:id', (req, res) => {
+  const { id } = req.params;
+  const filters = listJiraFilters();
+  const filtered = filters.filter((f) => f.id !== id);
+  if (filtered.length === filters.length) {
+    return res.status(404).json({ error: 'Filter not found.' });
+  }
+  saveJiraFilters(filtered);
+  res.status(204).end();
+});
+
+// Fetch issues for a filter
+router.get('/:id/issues', async (req, res) => {
+  const { id } = req.params;
+  const filters = listJiraFilters();
+  const filter = filters.find((f) => f.id === id);
+  if (!filter) {
+    return res.status(404).json({ error: 'Filter not found.' });
+  }
+
+  const jiraHost = getJiraHost();
+  if (!jiraHost) {
+    return res.status(400).json({ error: 'Jira domain is not configured. Please set Domain in Settings.' });
+  }
+
+  const settings = readSettings();
+  const token = settings.jiraAccessToken;
+
+  try {
+    const url = `https://${jiraHost}/rest/api/2/search?jql=filter%3D${encodeURIComponent(filter.filterId)}&maxResults=200&fields=summary,priority,duedate,status`;
+    const headers = {};
+    if (token) {
+      headers.Authorization = token.startsWith('Bearer ') ? token : `Bearer ${token}`;
+    }
+
+    const response = await httpClient.get(url, { headers });
+    if (response.status !== 200) {
+      const errMsg = response.data?.errorMessages?.[0] || response.data?.message || `Jira API returned status ${response.status}`;
+      return res.status(response.status).json({ error: errMsg, targetUrl: url });
+    }
+
+    const rawIssues = response.data?.issues || [];
+    const issues = rawIssues.map((issue) => {
+      const key = issue.key || issue.id;
+      const fields = issue.fields || {};
+      return {
+        id: issue.id,
+        key,
+        summary: fields.summary || '(No summary)',
+        priority: fields.priority || null,
+        dueDate: fields.duedate || null,
+        status: fields.status?.name || null,
+        url: `https://${jiraHost}/browse/${key}`
+      };
+    });
+
+    // Sort by priority descending
+    issues.sort((a, b) => getPriorityRank(b.priority) - getPriorityRank(a.priority));
+
+    res.json({ filter, issues });
+  } catch (error) {
+    const targetUrl = `https://${jiraHost}/rest/api/2/search?jql=filter%3D${encodeURIComponent(filter.filterId)}&maxResults=200&fields=summary,priority,duedate,status`;
+    res.status(500).json({ error: error.message || 'Failed to fetch Jira issues.', targetUrl });
+  }
+});
+
+export default router;

package/server/routes/pr-review.js

@@ -1,3 +1,5 @@
+import https from 'node:https';
+import axios from 'axios';
 import { Router } from 'express';
 import { readSettings } from '../repositories/settings.js';
 
@@ -5,6 +7,12 @@ const router = Router();
 const previewLimit = 2000;
 let lastUsedHost = '';
 
+const httpsAgent = new https.Agent({ rejectUnauthorized: false });
+const httpClient = axios.create({
+  httpsAgent,
+  validateStatus: () => true
+});
+
 function getBitbucketHost() {
   if (lastUsedHost) return lastUsedHost;
   const settings = readSettings();
@@ -202,22 +210,22 @@ router.post('/check', async (req, res) => {
   try {
     // 1. Fetch Pull Request details to show basic info
     const prUrl = `https://${host}/rest/api/1.0/projects/${projectKey}/repos/${repositorySlug}/pull-requests/${pullRequestId}`;
-    const prRes = await fetch(prUrl, { headers });
-    if (!prRes.ok) {
+    const prRes = await httpClient.get(prUrl, { headers });
+    if (prRes.status < 200 || prRes.status >= 300) {
       if (prRes.status === 401) {
-        return res.status(401).json({ error: 'Unauthorized. Please check your Bitbucket Access Token in Settings.' });
+        return res.status(401).json({ error: 'Unauthorized. Please check your Bitbucket Access Token in Settings.', targetUrl: prUrl });
       }
-      return res.status(prRes.status).json({ error: `Failed to fetch PR info: ${prRes.statusText}` });
+      return res.status(prRes.status).json({ error: `Failed to fetch PR info: ${prRes.statusText || prRes.status}`, targetUrl: prUrl });
     }
-    const prInfo = await prRes.json();
+    const prInfo = prRes.data;
 
     // 2. Fetch changes
     const changesUrl = `https://${host}/rest/api/1.0/projects/${projectKey}/repos/${repositorySlug}/pull-requests/${pullRequestId}/changes?limit=1000`;
-    const changesRes = await fetch(changesUrl, { headers });
-    if (!changesRes.ok) {
-      return res.status(changesRes.status).json({ error: `Failed to fetch PR changes: ${changesRes.statusText}` });
+    const changesRes = await httpClient.get(changesUrl, { headers });
+    if (changesRes.status < 200 || changesRes.status >= 300) {
+      return res.status(changesRes.status).json({ error: `Failed to fetch PR changes: ${changesRes.statusText || changesRes.status}`, targetUrl: changesUrl });
     }
-    const changesData = await changesRes.json();
+    const changesData = changesRes.data;
 
     const allChanges = changesData.values || [];
     const filteredOut = [];
@@ -242,10 +250,10 @@ router.post('/check', async (req, res) => {
     for (const change of targetChanges) {
       const filePath = change.path.toString;
       const diffUrl = `https://${host}/rest/api/1.0/projects/${projectKey}/repos/${repositorySlug}/pull-requests/${pullRequestId}/diff/${encodeURIComponent(filePath)}?context=0`;
-      const diffRes = await fetch(diffUrl, { headers });
-      if (!diffRes.ok) continue; // skip file if diff cannot be retrieved
+      const diffRes = await httpClient.get(diffUrl, { headers });
+      if (diffRes.status < 200 || diffRes.status >= 300) continue; // skip file if diff cannot be retrieved
 
-      const diffData = await diffRes.json();
+      const diffData = diffRes.data;
       const fileIssues = analyzeDiff(filePath, diffData.hunks);
 
       if (fileIssues.length > 0) {
@@ -321,16 +329,16 @@ router.get('/my-prs', async (req, res) => {
   const headers = { 'Accept': 'application/json' };
   if (token) headers['Authorization'] = `Bearer ${token}`;
 
+  const url = `https://${host}/rest/api/1.0/dashboard/pull-requests?role=author&state=OPEN&limit=100`;
   try {
-    const url = `https://${host}/rest/api/1.0/dashboard/pull-requests?role=author&state=OPEN&limit=100`;
-    const response = await fetch(url, { headers });
-    if (!response.ok) {
+    const response = await httpClient.get(url, { headers });
+    if (response.status < 200 || response.status >= 300) {
       if (response.status === 401) {
-        return res.status(401).json({ error: 'Unauthorized. Please check your Bitbucket Token.' });
+        return res.status(401).json({ error: 'Unauthorized. Please check your Bitbucket Token.', targetUrl: url });
       }
-      return res.status(response.status).json({ error: `Bitbucket API error: ${response.statusText}` });
+      return res.status(response.status).json({ error: `Bitbucket API error: ${response.statusText || response.status}`, targetUrl: url });
     }
-    const data = await response.json();
+    const data = response.data;
     const values = data.values || [];
 
     const sorted = values.sort((a, b) => {
@@ -342,7 +350,7 @@ router.get('/my-prs', async (req, res) => {
 
     res.json({ values: enrichPrList(sorted, host) });
   } catch (error) {
-    res.status(500).json({ error: error.message });
+    res.status(500).json({ error: error.message, targetUrl: url });
   }
 });
 
@@ -355,23 +363,23 @@ router.get('/review-prs', async (req, res) => {
   const headers = { 'Accept': 'application/json' };
   if (token) headers['Authorization'] = `Bearer ${token}`;
 
+  const url = `https://${host}/rest/api/1.0/dashboard/pull-requests?role=reviewer&state=OPEN&limit=100`;
   try {
-    const url = `https://${host}/rest/api/1.0/dashboard/pull-requests?role=reviewer&state=OPEN&limit=100`;
-    const response = await fetch(url, { headers });
-    if (!response.ok) {
+    const response = await httpClient.get(url, { headers });
+    if (response.status < 200 || response.status >= 300) {
       if (response.status === 401) {
-        return res.status(401).json({ error: 'Unauthorized. Please check your Bitbucket Token.' });
+        return res.status(401).json({ error: 'Unauthorized. Please check your Bitbucket Token.', targetUrl: url });
       }
-      return res.status(response.status).json({ error: `Bitbucket API error: ${response.statusText}` });
+      return res.status(response.status).json({ error: `Bitbucket API error: ${response.statusText || response.status}`, targetUrl: url });
     }
-    const data = await response.json();
+    const data = response.data;
     const values = data.values || [];
 
     const sorted = values.sort((a, b) => (b.updatedDate || 0) - (a.updatedDate || 0));
 
     res.json({ values: enrichPrList(sorted, host) });
   } catch (error) {
-    res.status(500).json({ error: error.message });
+    res.status(500).json({ error: error.message, targetUrl: url });
   }
 });
 
@@ -410,23 +418,20 @@ router.post('/comment', async (req, res) => {
   }
 
   try {
-    const response = await fetch(url, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify(payload)
-    });
+    const response = await httpClient.post(url, payload, { headers });
 
-    if (!response.ok) {
-      const errJson = await response.json().catch(() => ({}));
+    if (response.status < 200 || response.status >= 300) {
+      const errJson = response.data || {};
       return res.status(response.status).json({
-        error: errJson.errors?.[0]?.message || errJson.message || `Bitbucket API error: ${response.statusText}`
+        error: errJson.errors?.[0]?.message || errJson.message || `Bitbucket API error: ${response.statusText || response.status}`,
+        targetUrl: url
       });
     }
 
-    const data = await response.json();
+    const data = response.data;
     res.json({ success: true, data });
   } catch (error) {
-    res.status(500).json({ error: error.message });
+    res.status(500).json({ error: error.message, targetUrl: url });
   }
 });
 

package/server/routes/settings.js

@@ -1,5 +1,6 @@
 import { Router } from 'express';
-import { saveAccessToken, saveClipboardEnabled, saveDomain, settingsStatus } from '../repositories/settings.js';
+import { saveAccessToken, saveClipboardEnabled, saveDefaultBrowser, saveDefaultEditor, saveDomain, saveJiraIssuePrefix, settingsStatus } from '../repositories/settings.js';
+import { openInSystemBrowser } from '../services/browser.js';
 
 const router = Router();
 
@@ -9,6 +10,27 @@ router.put('/domain', (req, res) => {
   if (typeof domain !== 'string') return res.status(400).json({ error: 'Domain must be a string.' });
   res.json(saveDomain(domain.trim()));
 });
+router.put('/jira-issue-prefix', (req, res) => {
+  const { jiraIssuePrefix } = req.body || {};
+  if (typeof jiraIssuePrefix !== 'string') return res.status(400).json({ error: 'Jira issue prefix must be a string.' });
+  res.json(saveJiraIssuePrefix(jiraIssuePrefix.trim()));
+});
+router.put('/default-editor', (req, res) => {
+  const { defaultEditor } = req.body || {};
+  if (typeof defaultEditor !== 'string') return res.status(400).json({ error: 'defaultEditor must be a string.' });
+  res.json(saveDefaultEditor(defaultEditor.trim()));
+});
+router.put('/default-browser', (req, res) => {
+  const { defaultBrowser } = req.body || {};
+  if (typeof defaultBrowser !== 'string') return res.status(400).json({ error: 'defaultBrowser must be a string.' });
+  res.json(saveDefaultBrowser(defaultBrowser.trim()));
+});
+router.post('/open-url', (req, res) => {
+  const { url } = req.body || {};
+  if (typeof url !== 'string' || !url) return res.status(400).json({ error: 'URL must be a non-empty string.' });
+  openInSystemBrowser(url.trim());
+  res.json({ success: true });
+});
 router.put('/clipboard-enabled', (req, res) => {
   const { enabled } = req.body || {};
   if (typeof enabled !== 'boolean') return res.status(400).json({ error: 'Enabled must be a boolean.' });