buddy-workbench 0.1.12 → 0.1.13

package/server/services/clipboard-history.js

@@ -1,13 +1,125 @@
 import { execFile } from 'node:child_process';
+import { createHash, randomUUID } from 'node:crypto';
 import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { promisify } from 'node:util';
+import { fileURLToPath } from 'node:url';
+import encodeMozjpeg, { init as initMozjpeg } from '../../ui/node_modules/@jsquash/jpeg/encode.js';
 import { paths } from '../config.js';
 import { readSettings } from '../repositories/settings.js';
 
 const execFileAsync = promisify(execFile);
 const previewLimit = 2000;
 let lastValue = '';
+let lastImageHash = '';
+let mozjpegWasmModule = null;
+
+async function compressMozjpeg(rgbaBuf, width, height, quality = 75) {
+  if (!mozjpegWasmModule) {
+    const wasmPath = fileURLToPath(import.meta.resolve('../../ui/node_modules/@jsquash/jpeg/codec/enc/mozjpeg_enc.wasm'));
+    mozjpegWasmModule = await WebAssembly.compile(readFileSync(wasmPath));
+    await initMozjpeg(mozjpegWasmModule);
+  }
+  const data = new Uint8ClampedArray(rgbaBuf.buffer, rgbaBuf.byteOffset, rgbaBuf.byteLength);
+  const arrayBuf = await encodeMozjpeg({ data, width, height }, { quality });
+  return Buffer.from(arrayBuf);
+}
+
+async function getMacClipboardImageData() {
+  const jsaScript = `
+    ObjC.import("AppKit");
+    var pb = $.NSPasteboard.generalPasteboard;
+    var data = pb.dataForType($.NSPasteboardTypePNG);
+    if (data.isNil()) {
+      data = pb.dataForType($.NSPasteboardTypeTIFF);
+    }
+    if (!data.isNil()) {
+      var image = $.NSImage.alloc.initWithData(data);
+      if (!image.isNil()) {
+        var tiff = image.TIFFRepresentation;
+        var rep = $.NSBitmapImageRep.imageRepWithData(tiff);
+        var w = rep.pixelsWide;
+        var h = rep.pixelsHigh;
+        var rgbaRep = $.NSBitmapImageRep.alloc.initWithBitmapDataPlanesPixelsWidePixelsHighBitsPerSampleSamplesPerPixelHasAlphaIsPlanarColorSpaceNameBytesPerRowBitsPerPixel(
+          null, w, h, 8, 4, true, false, $.NSDeviceRGBColorSpace, w * 4, 32
+        );
+        $.NSGraphicsContext.saveGraphicsState;
+        var ctx = $.NSGraphicsContext.graphicsContextWithBitmapImageRep(rgbaRep);
+        $.NSGraphicsContext.currentContext = ctx;
+        rep.drawInRect($.NSMakeRect(0, 0, w, h));
+        $.NSGraphicsContext.restoreGraphicsState;
+        var rawBytes = rgbaRep.bitmapData;
+        var nsData = $.NSData.dataWithBytesLength(rawBytes, w * h * 4);
+        w + ":" + h + ":" + nsData.base64EncodedStringWithOptions(0).js;
+      } else {
+        "";
+      }
+    } else {
+      "";
+    }
+  `;
+  try {
+    const { stdout } = await execFileAsync('osascript', ['-l', 'JavaScript', '-e', jsaScript], { timeout: 3000 });
+    const str = stdout.trim();
+    if (!str) return null;
+    const firstColon = str.indexOf(':');
+    const secondColon = str.indexOf(':', firstColon + 1);
+    if (firstColon === -1 || secondColon === -1) return null;
+    const width = parseInt(str.slice(0, firstColon), 10);
+    const height = parseInt(str.slice(firstColon + 1, secondColon), 10);
+    const base64 = str.slice(secondColon + 1);
+    if (!width || !height || !base64) return null;
+    return { width, height, rgbaBuf: Buffer.from(base64, 'base64') };
+  } catch {
+    return null;
+  }
+}
+
+async function getMacClipboardImageBuffer() {
+  const swiftCode = `
+import Cocoa
+let pb = NSPasteboard.general
+if let data = pb.data(forType: .png) {
+    FileHandle.standardOutput.write(data)
+} else if let data = pb.data(forType: .tiff) {
+    if let img = NSImage(data: data),
+       let tiff = img.tiffRepresentation,
+       let rep = NSBitmapImageRep(data: tiff),
+       let png = rep.representation(using: .png, properties: [:]) {
+        FileHandle.standardOutput.write(png)
+    }
+}
+`;
+  try {
+    const { stdout } = await execFileAsync('swift', ['-e', swiftCode], { encoding: 'buffer', timeout: 3000 });
+    if (stdout && stdout.length > 0) return stdout;
+  } catch {
+    try {
+      const jsaScript = `
+        ObjC.import("AppKit");
+        var pb = $.NSPasteboard.generalPasteboard;
+        var data = pb.dataForType($.NSPasteboardTypePNG);
+        if (data.isNil()) {
+          var tiffData = pb.dataForType($.NSPasteboardTypeTIFF);
+          if (!tiffData.isNil()) {
+            var img = $.NSImage.alloc.initWithData(tiffData);
+            var rep = $.NSBitmapImageRep.imageRepWithData(img.TIFFRepresentation);
+            data = rep.representationUsingTypeProperties($.NSPNGFileType, $());
+          }
+        }
+        if (!data.isNil()) {
+          data.base64EncodedStringWithOptions(0).js;
+        } else {
+          "";
+        }
+      `;
+      const { stdout } = await execFileAsync('osascript', ['-l', 'JavaScript', '-e', jsaScript], { timeout: 3000 });
+      const str = stdout.trim();
+      if (str) return Buffer.from(str, 'base64');
+    } catch {}
+  }
+  return null;
+}
 
 function today() { return new Intl.DateTimeFormat('en-CA').format(new Date()); }
 function dayFile(date) { const [year, month, day] = date.split('-'); return join(paths.clipboardDir, year, month, `${day}.json`); }
@@ -105,61 +217,126 @@ export function deleteClipboardItem(date, id) {
 
 export async function captureClipboard() {
   if (process.platform !== 'darwin') return;
-  if (readSettings().clipboardEnabled === false) return;
+  const settings = readSettings();
+  if (settings.clipboardEnabled === false) return;
+
+  // 1. Text capture
   try {
-    const { stdout } = await execFileAsync('pbpaste'); const text = stdout.trim();
-    if (!text || text === lastValue) return;
-    lastValue = text;
-    
-    const now = Date.now();
-    const limit = now - 60 * 60 * 1000;
-    const date = today();
-    const items = dayItems(date);
-    
-    let recentItems = [...items];
-    const yesterdayDate = new Intl.DateTimeFormat('en-CA').format(new Date(now - 24 * 60 * 60 * 1000));
-    if (date !== yesterdayDate) {
-      recentItems = [...recentItems, ...dayItems(yesterdayDate)];
-    }
-    
-    const oneHourItems = recentItems.filter(item => {
-      const itemTime = new Date(item.createdAt).getTime();
-      return itemTime >= limit;
-    });
-    
-    const alreadyExists = oneHourItems.some(item => {
-      if (item.text !== undefined) {
-        return item.text === text;
-      }
-      if (item.contentFile) {
-        const prefix = item.preview.slice(0, -1);
-        if (text.startsWith(prefix)) {
-          try {
-            const fullText = readFileSync(join(paths.clipboardDir, 'content', item.contentFile), 'utf8');
-            return fullText === text;
-          } catch {
-            return false;
+    const { stdout } = await execFileAsync('pbpaste');
+    const text = stdout.trim();
+    if (text && text !== lastValue) {
+      lastValue = text;
+      const deduplicateMinutes = typeof settings.clipboardDeduplicateMinutes === 'number' && !isNaN(settings.clipboardDeduplicateMinutes) ? settings.clipboardDeduplicateMinutes : 60;
+      const date = today();
+      const items = dayItems(date);
+      
+      let alreadyExists = false;
+      if (deduplicateMinutes > 0) {
+        const now = Date.now();
+        const limit = now - deduplicateMinutes * 60 * 1000;
+        const minDate = new Intl.DateTimeFormat('en-CA').format(new Date(limit));
+        
+        let recentItems = [];
+        const dates = clipboardDates();
+        for (const d of dates) {
+          if (d >= minDate) {
+            recentItems.push(...dayItems(d));
+          } else {
+            break;
           }
         }
+        
+        const dedupeWindowItems = recentItems.filter(item => new Date(item.createdAt).getTime() >= limit);
+        
+        alreadyExists = dedupeWindowItems.some(item => {
+          if (item.text !== undefined) {
+            return item.text === text;
+          }
+          if (item.contentFile) {
+            const prefix = item.preview.slice(0, -1);
+            if (text.startsWith(prefix)) {
+              try {
+                const fullText = readFileSync(join(paths.clipboardDir, 'content', item.contentFile), 'utf8');
+                return fullText === text;
+              } catch {
+                return false;
+              }
+            }
+          }
+          return false;
+        });
+      }
+      
+      if (!alreadyExists) {
+        const id = randomUUID(); const isLong = text.length > previewLimit;
+        if (isLong) { mkdirSync(join(paths.clipboardDir, 'content'), { recursive: true }); writeFileSync(join(paths.clipboardDir, 'content', id), text, 'utf8'); }
+        const item = isLong ? { id, preview: `${text.slice(0, previewLimit)}…`, contentFile: id, createdAt: new Date().toISOString() } : { id, text, createdAt: new Date().toISOString() };
+        writeJson(dayFile(date), [item, ...items].slice(0, 200));
       }
-      return false;
-    });
-    
-    if (alreadyExists) return;
-    
-    const id = crypto.randomUUID(); const isLong = text.length > previewLimit;
-    if (isLong) { mkdirSync(join(paths.clipboardDir, 'content'), { recursive: true }); writeFileSync(join(paths.clipboardDir, 'content', id), text, 'utf8'); }
-    const item = isLong ? { id, preview: `${text.slice(0, previewLimit)}…`, contentFile: id, createdAt: new Date().toISOString() } : { id, text, createdAt: new Date().toISOString() };
-    writeJson(dayFile(date), [item, ...items].slice(0, 200));
+    }
   } catch {}
+
+  // 2. Image capture (Mac only & clipboardImageEnabled !== false)
+  if (settings.clipboardImageEnabled !== false) {
+    try {
+      const imageData = await getMacClipboardImageData();
+      if (imageData && imageData.rgbaBuf.length > 0) {
+        const hash = createHash('md5').update(imageData.rgbaBuf).digest('hex');
+        if (hash !== lastImageHash) {
+          let isDuplicate = false;
+          const dates = clipboardDates();
+          for (const d of dates) {
+            const dayList = dayItems(d);
+            if (dayList.some(item => item.imageHash === hash)) {
+              isDuplicate = true;
+              break;
+            }
+          }
+
+          lastImageHash = hash;
+          if (!isDuplicate) {
+            try {
+              const mozjpegBuf = await compressMozjpeg(imageData.rgbaBuf, imageData.width, imageData.height, 75);
+              saveClipboardImage(mozjpegBuf, 'jpg', hash);
+            } catch {
+              const rawBuf = await getMacClipboardImageBuffer();
+              if (rawBuf) saveClipboardImage(rawBuf, 'png', hash);
+            }
+          }
+        }
+      } else {
+        const imageBuffer = await getMacClipboardImageBuffer();
+        if (imageBuffer && imageBuffer.length > 0) {
+          const hash = createHash('md5').update(imageBuffer).digest('hex');
+          if (hash !== lastImageHash) {
+            let isDuplicate = false;
+            const dates = clipboardDates();
+            for (const d of dates) {
+              const dayList = dayItems(d);
+              if (dayList.some(item => item.imageHash === hash)) {
+                isDuplicate = true;
+                break;
+              }
+            }
+
+            lastImageHash = hash;
+            if (!isDuplicate) {
+              saveClipboardImage(imageBuffer, 'png', hash);
+            }
+          }
+        }
+      }
+    } catch {}
+  }
 }
 
 export function startClipboardCapture() { captureClipboard(); const timer = setInterval(captureClipboard, 2000); timer.unref(); }
 
-export function saveClipboardImage(buffer, ext = 'png') {
+export function saveClipboardImage(buffer, ext = 'png', imageHash = '') {
   const date = today();
-  const id = crypto.randomUUID();
+  const id = randomUUID();
   const filename = `${id}.${ext}`;
+  const hash = imageHash || createHash('md5').update(buffer).digest('hex');
   
   mkdirSync(join(paths.clipboardDir, 'content'), { recursive: true });
   writeFileSync(join(paths.clipboardDir, 'content', filename), buffer);
@@ -167,6 +344,7 @@ export function saveClipboardImage(buffer, ext = 'png') {
   const item = {
     id,
     imageFile: filename,
+    imageHash: hash,
     createdAt: new Date().toISOString()
   };
   

package/server/services/dialog.js

@@ -0,0 +1,43 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+export async function selectDirectory() {
+  if (process.platform === 'darwin') {
+    try {
+      const { stdout } = await execFileAsync('osascript', [
+        '-e',
+        'POSIX path of (choose folder with prompt "Select Project Folder")'
+      ]);
+      const dirPath = stdout.trim();
+      return dirPath ? { path: dirPath, canceled: false } : { path: null, canceled: true };
+    } catch {
+      return { path: null, canceled: true };
+    }
+  } else if (process.platform === 'win32') {
+    try {
+      const psScript = `
+        Add-Type -AssemblyName System.Windows.Forms
+        $dialog = New-Object System.Windows.Forms.FolderBrowserDialog
+        $dialog.Description = "Select Project Folder"
+        if ($dialog.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) {
+            Write-Output $dialog.SelectedPath
+        }
+      `;
+      const { stdout } = await execFileAsync('powershell', ['-NoProfile', '-Command', psScript]);
+      const dirPath = stdout.trim();
+      return dirPath ? { path: dirPath, canceled: false } : { path: null, canceled: true };
+    } catch {
+      return { path: null, canceled: true };
+    }
+  } else {
+    try {
+      const { stdout } = await execFileAsync('zenity', ['--file-selection', '--directory', '--title=Select Project Folder']);
+      const dirPath = stdout.trim();
+      return dirPath ? { path: dirPath, canceled: false } : { path: null, canceled: true };
+    } catch {
+      return { path: null, canceled: true };
+    }
+  }
+}

package/server/services/postman-parser.js

@@ -0,0 +1,300 @@
+import { randomUUID } from 'node:crypto';
+
+function generateId() {
+  return typeof randomUUID === 'function'
+    ? randomUUID()
+    : `pm_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+}
+
+function parseUrl(urlObj) {
+  if (!urlObj) return '';
+  if (typeof urlObj === 'string') return urlObj;
+  if (urlObj.raw) return urlObj.raw;
+  
+  const protocol = urlObj.protocol ? `${urlObj.protocol}://` : '';
+  const host = Array.isArray(urlObj.host) ? urlObj.host.join('.') : (urlObj.host || '');
+  const path = Array.isArray(urlObj.path) ? `/${urlObj.path.join('/')}` : (urlObj.path || '');
+  let query = '';
+  if (Array.isArray(urlObj.query) && urlObj.query.length > 0) {
+    const activeParams = urlObj.query
+      .filter((q) => !q.disabled && q.key)
+      .map((q) => `${encodeURIComponent(q.key)}=${encodeURIComponent(q.value || '')}`);
+    if (activeParams.length > 0) {
+      query = `?${activeParams.join('&')}`;
+    }
+  }
+  return `${protocol}${host}${path}${query}`;
+}
+
+function parseHeaders(headers) {
+  if (!Array.isArray(headers)) return [];
+  return headers.map((h) => ({
+    key: h.key || '',
+    value: h.value || '',
+    enabled: !h.disabled,
+    description: h.description || ''
+  }));
+}
+
+function parseParamsFromUrl(urlStr) {
+  if (!urlStr || typeof urlStr !== 'string') return [];
+  const queryIndex = urlStr.indexOf('?');
+  if (queryIndex === -1) return [];
+  const queryString = urlStr.slice(queryIndex + 1);
+  const searchParams = new URLSearchParams(queryString);
+  const params = [];
+  searchParams.forEach((value, key) => {
+    params.push({ key, value, enabled: true });
+  });
+  return params;
+}
+
+function parseBody(bodyObj) {
+  if (!bodyObj) return { mode: 'none', raw: '', json: '', formdata: [], urlencoded: [] };
+  const mode = bodyObj.mode || 'none';
+  let raw = bodyObj.raw || '';
+  let json = '';
+
+  if (mode === 'raw') {
+    if (bodyObj.options?.raw?.language === 'json') {
+      json = raw;
+    } else {
+      try {
+        JSON.parse(raw);
+        json = raw;
+      } catch {
+        json = '';
+      }
+    }
+  }
+
+  const formdata = Array.isArray(bodyObj.formdata)
+    ? bodyObj.formdata.map((item) => ({
+        key: item.key || '',
+        value: item.value || '',
+        type: item.type || 'text',
+        enabled: !item.disabled
+      }))
+    : [];
+
+  const urlencoded = Array.isArray(bodyObj.urlencoded)
+    ? bodyObj.urlencoded.map((item) => ({
+        key: item.key || '',
+        value: item.value || '',
+        enabled: !item.disabled
+      }))
+    : [];
+
+  return { mode, raw, json, formdata, urlencoded };
+}
+
+function parseAuth(authObj) {
+  if (!authObj || !authObj.type) return { type: 'none', token: '', username: '', password: '' };
+  const type = authObj.type;
+  if (type === 'bearer') {
+    const tokenObj = Array.isArray(authObj.bearer) ? authObj.bearer.find((b) => b.key === 'token') : null;
+    return { type: 'bearer', token: tokenObj?.value || '', username: '', password: '' };
+  }
+  if (type === 'basic') {
+    const userObj = Array.isArray(authObj.basic) ? authObj.basic.find((b) => b.key === 'username') : null;
+    const passObj = Array.isArray(authObj.basic) ? authObj.basic.find((b) => b.key === 'password') : null;
+    return { type: 'basic', token: '', username: userObj?.value || '', password: passObj?.value || '' };
+  }
+  return { type: 'none', token: '', username: '', password: '' };
+}
+
+function parseItem(item, folderId = null) {
+  const isFolder = Array.isArray(item.item);
+  if (isFolder) {
+    const currentFolderId = generateId();
+    const folderNode = {
+      id: currentFolderId,
+      name: item.name || 'Folder',
+      description: item.description || '',
+      parentId: folderId,
+      isFolder: true
+    };
+
+    let children = [];
+    item.item.forEach((subItem) => {
+      const res = parseItem(subItem, currentFolderId);
+      if (Array.isArray(res)) {
+        children.push(...res);
+      } else {
+        children.push(res);
+      }
+    });
+
+    return [folderNode, ...children];
+  }
+
+  // Request item
+  const reqObj = item.request || {};
+  const rawUrl = parseUrl(reqObj.url);
+  const parsedParams = parseParamsFromUrl(rawUrl);
+
+  const requestNode = {
+    id: generateId(),
+    name: item.name || 'Request',
+    description: typeof reqObj.description === 'string' ? reqObj.description : (item.description || ''),
+    parentId: folderId,
+    isFolder: false,
+    method: (reqObj.method || 'GET').toUpperCase(),
+    url: rawUrl,
+    params: parsedParams,
+    headers: parseHeaders(reqObj.header),
+    body: parseBody(reqObj.body),
+    auth: parseAuth(reqObj.auth)
+  };
+
+  return requestNode;
+}
+
+export function parseCurlCommand(curlStr) {
+  if (!curlStr || typeof curlStr !== 'string') throw new Error('Empty cURL command');
+
+  const cleaned = curlStr.replace(/\\\r?\n/g, ' ').trim();
+  const args = [];
+  const regex = /"([^"\\]*(?:\\.[^"\\]*)*)"|'([^'\\]*(?:\\.[^'\\]*)*)'|(\S+)/g;
+  let match;
+  while ((match = regex.exec(cleaned)) !== null) {
+    if (match[1] !== undefined) {
+      args.push(match[1].replace(/\\"/g, '"'));
+    } else if (match[2] !== undefined) {
+      args.push(match[2].replace(/\\'/g, "'"));
+    } else {
+      args.push(match[3]);
+    }
+  }
+
+  if (args.length === 0) throw new Error('Invalid cURL command');
+
+  let method = null;
+  let url = '';
+  const headers = [];
+  let bodyRaw = '';
+  let authInfo = { type: 'none' };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    if (arg === '-X' || arg === '--request') {
+      if (args[i + 1]) {
+        method = args[i + 1].toUpperCase();
+        i++;
+      }
+    } else if (arg === '-H' || arg === '--header') {
+      if (args[i + 1]) {
+        const headerStr = args[i + 1];
+        const colonIdx = headerStr.indexOf(':');
+        if (colonIdx > 0) {
+          const key = headerStr.slice(0, colonIdx).trim();
+          const value = headerStr.slice(colonIdx + 1).trim();
+          headers.push({ key, value, disabled: false });
+        }
+        i++;
+      }
+    } else if (['-d', '--data', '--data-raw', '--data-binary'].includes(arg)) {
+      if (args[i + 1]) {
+        bodyRaw = args[i + 1];
+        i++;
+      }
+    } else if (arg === '-u' || arg === '--user') {
+      if (args[i + 1]) {
+        const userPass = args[i + 1];
+        const [u, p] = userPass.split(':');
+        authInfo = { type: 'basic', username: u || '', password: p || '' };
+        i++;
+      }
+    } else if (arg === '--url') {
+      if (args[i + 1]) {
+        url = args[i + 1];
+        i++;
+      }
+    } else if (!arg.startsWith('-') && arg.toLowerCase() !== 'curl' && !url) {
+      url = arg;
+    }
+  }
+
+  if (!url) {
+    throw new Error('Could not find target URL in cURL command');
+  }
+
+  if (!method) {
+    method = bodyRaw ? 'POST' : 'GET';
+  }
+
+  let reqName = `${method} Request`;
+  try {
+    const parsedUrl = new URL(url.startsWith('http') ? url : `http://${url}`);
+    const pathname = parsedUrl.pathname;
+    if (pathname && pathname !== '/') {
+      const parts = pathname.split('/').filter(Boolean);
+      if (parts.length > 0) reqName = `${method} /${parts[parts.length - 1]}`;
+    } else {
+      reqName = `${method} ${parsedUrl.hostname}`;
+    }
+  } catch {}
+
+  return {
+    info: { name: `cURL: ${reqName}` },
+    item: [{
+      name: reqName,
+      request: {
+        method,
+        url,
+        header: headers,
+        body: bodyRaw ? { mode: 'raw', raw: bodyRaw } : undefined,
+        auth: authInfo.type !== 'none' ? authInfo : undefined
+      }
+    }]
+  };
+}
+
+export function parsePostmanCollection(jsonInput) {
+  let collectionData;
+  if (typeof jsonInput === 'string') {
+    const trimmed = jsonInput.trim();
+    if (trimmed.toLowerCase().startsWith('curl') || (trimmed.includes('-H') && trimmed.includes('http'))) {
+      collectionData = parseCurlCommand(trimmed);
+    } else {
+      collectionData = JSON.parse(trimmed);
+    }
+  } else {
+    collectionData = jsonInput;
+  }
+
+  const info = collectionData.info || {};
+  const items = Array.isArray(collectionData.item) ? collectionData.item : [];
+
+  const collectionId = generateId();
+  const collectionName = info.name || 'Imported Collection';
+  const description = info.description || '';
+
+  const variables = Array.isArray(collectionData.variable)
+    ? collectionData.variable.map((v) => ({
+        key: v.key || '',
+        value: v.value || '',
+        enabled: !v.disabled
+      }))
+    : [];
+
+  const parsedItems = [];
+  items.forEach((it) => {
+    const res = parseItem(it, null);
+    if (Array.isArray(res)) {
+      parsedItems.push(...res);
+    } else {
+      parsedItems.push(res);
+    }
+  });
+
+  return {
+    id: collectionId,
+    name: collectionName,
+    description: typeof description === 'string' ? description : '',
+    variables,
+    items: parsedItems,
+    createdAt: new Date().toISOString()
+  };
+}

package/server.js

@@ -17,6 +17,7 @@ import jiraFiltersRoutes from './server/routes/jira-filters.js';
 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 { addErrorRecord } from './server/repositories/errors.js';
 import { startClipboardCapture } from './server/services/clipboard-history.js';
 
@@ -69,6 +70,7 @@ app.use('/api/jira-filters', jiraFiltersRoutes);
 app.use('/api/todos', todoRoutes);
 app.use('/api/static-pages', staticPagesRoutes);
 app.use('/api/errors', errorRoutes);
+app.use('/api/postman', postmanRoutes);
 
 app.use((err, req, res, _next) => {
   addErrorRecord({