buddy-workbench 0.1.12 → 0.1.14

package/package.json

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

package/server/config.js

@@ -11,6 +11,7 @@ export const paths = {
   todos: join(root, 'data', 'todos.json'),
   staticPages: join(root, 'data', 'static-pages.json'),
   errors: join(root, 'data', 'errors.json'),
+  postman: join(root, 'data', 'postman.json'),
   shutdownLog: join(root, 'data', 'shutdown.log'),
   clipboardDir: join(root, 'data', 'clipboard'),
   plugins: join(root, 'plugins'),

package/server/repositories/postman.js

@@ -0,0 +1,31 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { paths } from '../config.js';
+
+const defaultData = {
+  collections: [],
+  environments: [],
+  activeEnvironmentId: null
+};
+
+export function getPostmanData() {
+  try {
+    if (!existsSync(paths.postman)) {
+      return defaultData;
+    }
+    const raw = readFileSync(paths.postman, 'utf8');
+    const parsed = JSON.parse(raw);
+    return {
+      collections: parsed.collections || [],
+      environments: parsed.environments || [],
+      activeEnvironmentId: parsed.activeEnvironmentId || null
+    };
+  } catch (error) {
+    return defaultData;
+  }
+}
+
+export function savePostmanData(data) {
+  mkdirSync(dirname(paths.postman), { recursive: true });
+  writeFileSync(paths.postman, JSON.stringify(data, null, 2), 'utf8');
+}

package/server/repositories/settings.js

@@ -17,7 +17,10 @@ export function settingsStatus() {
     bitbucketTokenConfigured: Boolean(settings.bitbucketAccessToken),
     jiraTokenConfigured: Boolean(settings.jiraAccessToken),
     confluenceTokenConfigured: Boolean(settings.confluenceAccessToken),
-    clipboardEnabled: settings.clipboardEnabled !== false
+    isMac: process.platform === 'darwin',
+    clipboardEnabled: settings.clipboardEnabled !== false,
+    clipboardImageEnabled: settings.clipboardImageEnabled !== false,
+    clipboardDeduplicateMinutes: typeof settings.clipboardDeduplicateMinutes === 'number' && !isNaN(settings.clipboardDeduplicateMinutes) ? settings.clipboardDeduplicateMinutes : 60
   };
 }
 
@@ -65,6 +68,23 @@ export function saveClipboardEnabled(enabled) {
   return settingsStatus();
 }
 
+export function saveClipboardImageEnabled(enabled) {
+  const settings = readSettings();
+  settings.clipboardImageEnabled = Boolean(enabled);
+  mkdirSync(dirname(paths.settings), { recursive: true });
+  writeFileSync(paths.settings, JSON.stringify(settings, null, 2), { mode: 0o600 });
+  return settingsStatus();
+}
+
+export function saveClipboardDeduplicateMinutes(minutes) {
+  const settings = readSettings();
+  const val = Number(minutes);
+  settings.clipboardDeduplicateMinutes = !isNaN(val) && val >= 0 ? val : 60;
+  mkdirSync(dirname(paths.settings), { recursive: true });
+  writeFileSync(paths.settings, JSON.stringify(settings, null, 2), { mode: 0o600 });
+  return settingsStatus();
+}
+
 const accessTokenFields = {
   bitbucket: 'bitbucketAccessToken',
   jira: 'jiraAccessToken',

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/postman.js

@@ -0,0 +1,283 @@
+import { Router } from 'express';
+import axios from 'axios';
+import { getPostmanData, savePostmanData } from '../repositories/postman.js';
+import { parsePostmanCollection } from '../services/postman-parser.js';
+
+const router = Router();
+
+// Variable substitution helper
+function replaceVariables(str, varMap) {
+  if (typeof str !== 'string') return str;
+  return str.replace(/\{\{\s*([\w.-]+)\s*\}\}/g, (match, key) => {
+    return varMap[key] !== undefined ? varMap[key] : match;
+  });
+}
+
+// GET all Postman workbench data
+router.get('/', (req, res) => {
+  try {
+    const data = getPostmanData();
+    res.json(data);
+  } catch (error) {
+    res.status(500).json({ error: error.message || 'Failed to fetch Postman data' });
+  }
+});
+
+// Import collection
+router.post('/import', (req, res) => {
+  try {
+    const { collectionJson } = req.body;
+    if (!collectionJson) {
+      return res.status(400).json({ error: 'Collection JSON content is required' });
+    }
+
+    const parsedCollection = parsePostmanCollection(collectionJson);
+    const data = getPostmanData();
+
+    // Check if collection with same ID or name exists
+    const existingIndex = data.collections.findIndex((c) => c.id === parsedCollection.id);
+    if (existingIndex >= 0) {
+      data.collections[existingIndex] = parsedCollection;
+    } else {
+      data.collections.unshift(parsedCollection);
+    }
+
+    savePostmanData(data);
+    res.status(201).json(parsedCollection);
+  } catch (error) {
+    res.status(400).json({ error: `Invalid Postman collection JSON: ${error.message}` });
+  }
+});
+
+// Create collection manually
+router.post('/collections', (req, res) => {
+  try {
+    const { name, description } = req.body;
+    if (!name) {
+      return res.status(400).json({ error: 'Collection name is required' });
+    }
+
+    const data = getPostmanData();
+    const newCollection = {
+      id: `col_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`,
+      name,
+      description: description || '',
+      variables: [],
+      items: [],
+      createdAt: new Date().toISOString()
+    };
+
+    data.collections.unshift(newCollection);
+    savePostmanData(data);
+    res.status(201).json(newCollection);
+  } catch (error) {
+    res.status(500).json({ error: error.message || 'Failed to create collection' });
+  }
+});
+
+// Update collection
+router.put('/collections/:id', (req, res) => {
+  try {
+    const { id } = req.params;
+    const { name, description, variables, items } = req.body;
+
+    const data = getPostmanData();
+    const index = data.collections.findIndex((c) => c.id === id);
+    if (index === -1) {
+      return res.status(404).json({ error: 'Collection not found' });
+    }
+
+    const updated = {
+      ...data.collections[index],
+      ...(name !== undefined && { name }),
+      ...(description !== undefined && { description }),
+      ...(variables !== undefined && { variables }),
+      ...(items !== undefined && { items }),
+      updatedAt: new Date().toISOString()
+    };
+
+    data.collections[index] = updated;
+    savePostmanData(data);
+    res.json(updated);
+  } catch (error) {
+    res.status(500).json({ error: error.message || 'Failed to update collection' });
+  }
+});
+
+// Delete collection
+router.delete('/collections/:id', (req, res) => {
+  try {
+    const { id } = req.params;
+    const data = getPostmanData();
+    data.collections = data.collections.filter((c) => c.id !== id);
+    savePostmanData(data);
+    res.json({ success: true });
+  } catch (error) {
+    res.status(500).json({ error: error.message || 'Failed to delete collection' });
+  }
+});
+
+// Save environments
+router.post('/environments', (req, res) => {
+  try {
+    const { environments, activeEnvironmentId } = req.body;
+    const data = getPostmanData();
+
+    if (Array.isArray(environments)) {
+      data.environments = environments;
+    }
+    if (activeEnvironmentId !== undefined) {
+      data.activeEnvironmentId = activeEnvironmentId;
+    }
+
+    savePostmanData(data);
+    res.json({
+      environments: data.environments,
+      activeEnvironmentId: data.activeEnvironmentId
+    });
+  } catch (error) {
+    res.status(500).json({ error: error.message || 'Failed to save environments' });
+  }
+});
+
+// HTTP Request Proxy execution
+router.post('/send', async (req, res) => {
+  try {
+    const {
+      method = 'GET',
+      url = '',
+      params = [],
+      headers = [],
+      body = {},
+      auth = {},
+      environmentVariables = [],
+      collectionVariables = []
+    } = req.body;
+
+    if (!url) {
+      return res.status(400).json({ error: 'Target URL is required' });
+    }
+
+    // Build variable mapping (environment overrides collection)
+    const varMap = {};
+    if (Array.isArray(collectionVariables)) {
+      collectionVariables.forEach((v) => {
+        if (v.enabled !== false && v.key) varMap[v.key] = v.value || '';
+      });
+    }
+    if (Array.isArray(environmentVariables)) {
+      environmentVariables.forEach((v) => {
+        if (v.enabled !== false && v.key) varMap[v.key] = v.value || '';
+      });
+    }
+
+    // Replace variables in URL
+    let resolvedUrl = replaceVariables(url, varMap);
+    if (!resolvedUrl.startsWith('http://') && !resolvedUrl.startsWith('https://')) {
+      resolvedUrl = `http://${resolvedUrl}`;
+    }
+
+    // Process Params
+    const queryObj = {};
+    if (Array.isArray(params)) {
+      params.forEach((p) => {
+        if (p.enabled !== false && p.key) {
+          queryObj[replaceVariables(p.key, varMap)] = replaceVariables(p.value || '', varMap);
+        }
+      });
+    }
+
+    // Process Headers
+    const reqHeaders = {};
+    if (Array.isArray(headers)) {
+      headers.forEach((h) => {
+        if (h.enabled !== false && h.key) {
+          reqHeaders[replaceVariables(h.key, varMap)] = replaceVariables(h.value || '', varMap);
+        }
+      });
+    }
+
+    // Process Auth
+    if (auth && auth.type === 'bearer' && auth.token) {
+      reqHeaders['Authorization'] = `Bearer ${replaceVariables(auth.token, varMap)}`;
+    } else if (auth && auth.type === 'basic' && (auth.username || auth.password)) {
+      const u = replaceVariables(auth.username || '', varMap);
+      const p = replaceVariables(auth.password || '', varMap);
+      const credentials = Buffer.from(`${u}:${p}`).toString('base64');
+      reqHeaders['Authorization'] = `Basic ${credentials}`;
+    }
+
+    // Process Body
+    let reqData = undefined;
+    if (['POST', 'PUT', 'PATCH', 'DELETE'].includes(method.toUpperCase())) {
+      if (body.mode === 'raw' || body.mode === 'json') {
+        const rawContent = replaceVariables(body.raw || body.json || '', varMap);
+        if (rawContent) {
+          reqData = rawContent;
+          if (!Object.keys(reqHeaders).some((k) => k.toLowerCase() === 'content-type')) {
+            reqHeaders['Content-Type'] = 'application/json';
+          }
+        }
+      } else if (body.mode === 'urlencoded') {
+        const urlParams = new URLSearchParams();
+        if (Array.isArray(body.urlencoded)) {
+          body.urlencoded.forEach((u) => {
+            if (u.enabled !== false && u.key) {
+              urlParams.append(replaceVariables(u.key, varMap), replaceVariables(u.value || '', varMap));
+            }
+          });
+        }
+        reqData = urlParams.toString();
+        if (!Object.keys(reqHeaders).some((k) => k.toLowerCase() === 'content-type')) {
+          reqHeaders['Content-Type'] = 'application/x-www-form-urlencoded';
+        }
+      }
+    }
+
+    const startTime = Date.now();
+    try {
+      const response = await axios({
+        method,
+        url: resolvedUrl,
+        params: Object.keys(queryObj).length > 0 ? queryObj : undefined,
+        headers: reqHeaders,
+        data: reqData,
+        validateStatus: () => true, // Don't throw on non-2xx status codes
+        timeout: 30000,
+        maxContentLength: 10 * 1024 * 1024 // 10MB limit
+      });
+
+      const durationMs = Date.now() - startTime;
+      let responseBody = response.data;
+      const responseHeaders = response.headers || {};
+      const contentType = responseHeaders['content-type'] || responseHeaders['Content-Type'] || '';
+
+      const bodyString = typeof responseBody === 'string'
+        ? responseBody
+        : JSON.stringify(responseBody || '');
+      const sizeBytes = Buffer.byteLength(bodyString, 'utf8');
+
+      res.json({
+        status: response.status,
+        statusText: response.statusText,
+        headers: responseHeaders,
+        data: responseBody,
+        durationMs,
+        sizeBytes,
+        contentType,
+        resolvedUrl
+      });
+    } catch (reqErr) {
+      const durationMs = Date.now() - startTime;
+      res.status(502).json({
+        error: reqErr.message || 'Request execution failed',
+        resolvedUrl,
+        durationMs
+      });
+    }
+  } catch (error) {
+    res.status(500).json({ error: error.message || 'Failed to send request' });
+  }
+});
+
+export default router;

package/server/routes/settings.js

@@ -1,6 +1,7 @@
 import { Router } from 'express';
-import { saveAccessToken, saveClipboardEnabled, saveDefaultBrowser, saveDefaultEditor, saveDomain, saveJiraIssuePrefix, settingsStatus } from '../repositories/settings.js';
-import { openInSystemBrowser } from '../services/browser.js';
+import { saveAccessToken, saveClipboardDeduplicateMinutes, saveClipboardEnabled, saveClipboardImageEnabled, saveDefaultBrowser, saveDefaultEditor, saveDomain, saveJiraIssuePrefix, settingsStatus } from '../repositories/settings.js';
+import { openInSystemBrowser, openInSystemEditor } from '../services/browser.js';
+import { selectDirectory } from '../services/dialog.js';
 
 const router = Router();
 
@@ -31,11 +32,35 @@ router.post('/open-url', (req, res) => {
   openInSystemBrowser(url.trim());
   res.json({ success: true });
 });
+router.post('/open-editor', (req, res) => {
+  const { path, location } = req.body || {};
+  if (typeof path !== 'string' || !path) return res.status(400).json({ error: 'Path must be a non-empty string.' });
+  openInSystemEditor(path.trim(), location ? String(location).trim() : '');
+  res.json({ success: true });
+});
+router.post('/select-directory', async (_req, res) => {
+  try {
+    const result = await selectDirectory();
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
 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.' });
   res.json(saveClipboardEnabled(enabled));
 });
+router.put('/clipboard-image-enabled', (req, res) => {
+  const { enabled } = req.body || {};
+  if (typeof enabled !== 'boolean') return res.status(400).json({ error: 'Enabled must be a boolean.' });
+  res.json(saveClipboardImageEnabled(enabled));
+});
+router.put('/clipboard-deduplicate-minutes', (req, res) => {
+  const { minutes } = req.body || {};
+  if (typeof minutes !== 'number' || isNaN(minutes) || minutes < 0) return res.status(400).json({ error: 'Minutes must be a non-negative number.' });
+  res.json(saveClipboardDeduplicateMinutes(minutes));
+});
 router.put('/:service-access-token', (req, res) => {
   const { token } = req.body || {};
   if (typeof token !== 'string') return res.status(400).json({ error: 'Token must be a string.' });