buddy-workbench 0.1.26 → 0.1.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buddy-workbench",
-  "version": "0.1.26",
+  "version": "0.1.28",
   "private": false,
   "type": "module",
   "bin": {
@@ -23,6 +23,25 @@
     "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"
   },
+  "devbuddyChangelog": [
+    {
+      "version": "0.1.27",
+      "name": "Data backups and settings refinements",
+      "notes": [
+        "Added data directory size statistics and secure .tar.gz backup import and export.",
+        "Refined the Static Pages action column header alignment."
+      ]
+    },
+    {
+      "version": "0.1.26",
+      "name": "Light theme and update center",
+      "notes": [
+        "Added a switchable light theme with persistent appearance settings.",
+        "Refined the light theme window color, primary actions, and navigation styling.",
+        "Added an npm-based update indicator and in-app Change Log."
+      ]
+    }
+  ],
   "dependencies": {
     "@jsquash/jpeg": "1.6.0",
     "axios": "1.7.9",

package/server/routes/data-backup.js

@@ -0,0 +1,285 @@
+import { createReadStream, createWriteStream, existsSync } from 'node:fs';
+import { copyFile, lstat, mkdir, mkdtemp, open, readdir, rm, stat, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join, posix, resolve, sep } from 'node:path';
+import { Transform } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { createGunzip, createGzip } from 'node:zlib';
+import { once } from 'node:events';
+import { Router } from 'express';
+import { paths } from '../config.js';
+
+const router = Router();
+const TAR_BLOCK_SIZE = 512;
+const MAX_COMPRESSED_BYTES = 512 * 1024 * 1024;
+const MAX_EXPANDED_BYTES = 2 * 1024 * 1024 * 1024;
+const MAX_IMPORTED_FILES = 100000;
+
+async function collectFiles(directory, relativeDirectory = '') {
+  if (!existsSync(directory)) return [];
+  const entries = await readdir(directory, { withFileTypes: true });
+  const files = [];
+
+  for (const entry of entries) {
+    const absolutePath = join(directory, entry.name);
+    const relativePath = relativeDirectory ? `${relativeDirectory}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      files.push(...await collectFiles(absolutePath, relativePath));
+    } else if (entry.isFile()) {
+      const fileStat = await lstat(absolutePath);
+      files.push({
+        absolutePath,
+        relativePath: relativePath.replaceAll('\\', '/'),
+        size: fileStat.size,
+        mtime: fileStat.mtime
+      });
+    }
+  }
+
+  return files;
+}
+
+async function dataDirectoryStats() {
+  const files = await collectFiles(paths.dataDir);
+  return {
+    sizeBytes: files.reduce((total, file) => total + file.size, 0),
+    fileCount: files.length
+  };
+}
+
+function splitTarPath(relativePath) {
+  if (Buffer.byteLength(relativePath) <= 100) return { name: relativePath, prefix: '' };
+  const separators = [...relativePath.matchAll(/\//g)].map((match) => match.index).reverse();
+  for (const index of separators) {
+    const prefix = relativePath.slice(0, index);
+    const name = relativePath.slice(index + 1);
+    if (Buffer.byteLength(prefix) <= 155 && Buffer.byteLength(name) <= 100) {
+      return { name, prefix };
+    }
+  }
+  throw new Error(`Backup path is too long: ${relativePath}`);
+}
+
+function writeString(buffer, value, offset, length) {
+  const encoded = Buffer.from(String(value));
+  if (encoded.length > length) throw new Error(`Tar field exceeds ${length} bytes.`);
+  encoded.copy(buffer, offset);
+}
+
+function writeOctal(buffer, value, offset, length) {
+  writeString(buffer, Math.max(0, value).toString(8).padStart(length - 1, '0'), offset, length - 1);
+}
+
+function createTarHeader(file) {
+  const header = Buffer.alloc(TAR_BLOCK_SIZE);
+  const { name, prefix } = splitTarPath(file.relativePath);
+  writeString(header, name, 0, 100);
+  writeOctal(header, 0o600, 100, 8);
+  writeOctal(header, 0, 108, 8);
+  writeOctal(header, 0, 116, 8);
+  writeOctal(header, file.size, 124, 12);
+  writeOctal(header, Math.floor(file.mtime.getTime() / 1000), 136, 12);
+  header.fill(0x20, 148, 156);
+  writeString(header, '0', 156, 1);
+  writeString(header, 'ustar', 257, 6);
+  writeString(header, '00', 263, 2);
+  writeString(header, 'devbuddy', 265, 32);
+  writeString(header, 'devbuddy', 297, 32);
+  if (prefix) writeString(header, prefix, 345, 155);
+
+  const checksum = header.reduce((total, byte) => total + byte, 0);
+  writeString(header, checksum.toString(8).padStart(6, '0'), 148, 6);
+  header[154] = 0;
+  header[155] = 0x20;
+  return header;
+}
+
+async function writeWithBackpressure(stream, chunk) {
+  if (!stream.write(chunk)) await once(stream, 'drain');
+}
+
+function nullTerminatedString(buffer, offset, length) {
+  const field = buffer.subarray(offset, offset + length);
+  const nullIndex = field.indexOf(0);
+  return field.subarray(0, nullIndex === -1 ? field.length : nullIndex).toString('utf8').trim();
+}
+
+function parseOctal(buffer, offset, length) {
+  const value = nullTerminatedString(buffer, offset, length).trim();
+  if (!value) return 0;
+  const parsed = Number.parseInt(value, 8);
+  if (!Number.isFinite(parsed) || parsed < 0) throw new Error('Backup contains an invalid tar size.');
+  return parsed;
+}
+
+function verifyTarHeader(header) {
+  const expected = parseOctal(header, 148, 8);
+  const copy = Buffer.from(header);
+  copy.fill(0x20, 148, 156);
+  const actual = copy.reduce((total, byte) => total + byte, 0);
+  if (expected !== actual) throw new Error('Backup archive checksum is invalid.');
+}
+
+function safeArchiveTarget(stagingDirectory, archivePath) {
+  const normalizedInput = archivePath.replaceAll('\\', '/');
+  const normalized = posix.normalize(normalizedInput);
+  if (
+    !normalized ||
+    normalized === '.' ||
+    normalized === '..' ||
+    normalized.startsWith('../') ||
+    normalized.startsWith('/') ||
+    /^[a-zA-Z]:/.test(normalized)
+  ) {
+    throw new Error(`Backup contains an unsafe path: ${archivePath}`);
+  }
+  const target = resolve(stagingDirectory, ...normalized.split('/'));
+  const stagingRoot = resolve(stagingDirectory);
+  if (target !== stagingRoot && !target.startsWith(`${stagingRoot}${sep}`)) {
+    throw new Error(`Backup path escapes the data directory: ${archivePath}`);
+  }
+  return target;
+}
+
+function byteLimit(limit, label) {
+  let total = 0;
+  return new Transform({
+    transform(chunk, _encoding, callback) {
+      total += chunk.length;
+      if (total > limit) {
+        callback(new Error(`${label} exceeds the supported size limit.`));
+      } else {
+        callback(null, chunk);
+      }
+    }
+  });
+}
+
+async function extractTar(tarPath, stagingDirectory) {
+  const archiveStat = await stat(tarPath);
+  const archive = await open(tarPath, 'r');
+  let offset = 0;
+  let importedFiles = 0;
+
+  try {
+    while (offset + TAR_BLOCK_SIZE <= archiveStat.size) {
+      const header = Buffer.alloc(TAR_BLOCK_SIZE);
+      const { bytesRead } = await archive.read(header, 0, TAR_BLOCK_SIZE, offset);
+      if (bytesRead !== TAR_BLOCK_SIZE) throw new Error('Backup archive ended unexpectedly.');
+      if (header.every((byte) => byte === 0)) break;
+      verifyTarHeader(header);
+
+      const name = nullTerminatedString(header, 0, 100);
+      const prefix = nullTerminatedString(header, 345, 155);
+      const archivePath = prefix ? `${prefix}/${name}` : name;
+      const type = String.fromCharCode(header[156] || 48);
+      const size = parseOctal(header, 124, 12);
+      const dataStart = offset + TAR_BLOCK_SIZE;
+      const dataEnd = dataStart + size;
+      if (dataEnd > archiveStat.size) throw new Error('Backup file data exceeds the archive size.');
+
+      const target = safeArchiveTarget(stagingDirectory, archivePath);
+      if (type === '5') {
+        await mkdir(target, { recursive: true });
+      } else if (type === '0') {
+        importedFiles += 1;
+        if (importedFiles > MAX_IMPORTED_FILES) throw new Error('Backup contains too many files.');
+        await mkdir(dirname(target), { recursive: true });
+        if (size === 0) {
+          await writeFile(target, Buffer.alloc(0), { mode: 0o600 });
+        } else {
+          await pipeline(
+            createReadStream(tarPath, { start: dataStart, end: dataEnd - 1 }),
+            createWriteStream(target, { mode: 0o600 })
+          );
+        }
+      } else {
+        throw new Error('Backup contains an unsupported link or special file.');
+      }
+
+      offset = dataStart + Math.ceil(size / TAR_BLOCK_SIZE) * TAR_BLOCK_SIZE;
+    }
+  } finally {
+    await archive.close();
+  }
+
+  return importedFiles;
+}
+
+async function mergeDirectory(source, destination) {
+  await mkdir(destination, { recursive: true });
+  const entries = await readdir(source, { withFileTypes: true });
+  for (const entry of entries) {
+    const sourcePath = join(source, entry.name);
+    const destinationPath = join(destination, entry.name);
+    if (entry.isDirectory()) {
+      await mergeDirectory(sourcePath, destinationPath);
+    } else if (entry.isFile()) {
+      await mkdir(dirname(destinationPath), { recursive: true });
+      await copyFile(sourcePath, destinationPath);
+    }
+  }
+}
+
+router.get('/stats', async (_req, res, next) => {
+  try {
+    res.json(await dataDirectoryStats());
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.get('/export', async (_req, res, next) => {
+  try {
+    const files = await collectFiles(paths.dataDir);
+    const date = new Date().toISOString().slice(0, 10);
+    res.setHeader('Content-Type', 'application/gzip');
+    res.setHeader('Content-Disposition', `attachment; filename="devbuddy-data-${date}.tar.gz"`);
+
+    const gzip = createGzip({ level: 6 });
+    gzip.pipe(res);
+    for (const file of files) {
+      await writeWithBackpressure(gzip, createTarHeader(file));
+      const readOptions = file.size > 0 ? { end: file.size - 1 } : undefined;
+      for await (const chunk of createReadStream(file.absolutePath, readOptions)) {
+        await writeWithBackpressure(gzip, chunk);
+      }
+      const padding = (TAR_BLOCK_SIZE - (file.size % TAR_BLOCK_SIZE)) % TAR_BLOCK_SIZE;
+      if (padding) await writeWithBackpressure(gzip, Buffer.alloc(padding));
+    }
+    await writeWithBackpressure(gzip, Buffer.alloc(TAR_BLOCK_SIZE * 2));
+    gzip.end();
+  } catch (error) {
+    if (!res.headersSent) next(error);
+    else res.destroy(error);
+  }
+});
+
+router.post('/import', async (req, res, next) => {
+  const temporaryDirectory = await mkdtemp(join(tmpdir(), 'devbuddy-backup-'));
+  const tarPath = join(temporaryDirectory, 'backup.tar');
+  const stagingDirectory = join(temporaryDirectory, 'data');
+
+  try {
+    await mkdir(stagingDirectory, { recursive: true });
+    await pipeline(
+      req,
+      byteLimit(MAX_COMPRESSED_BYTES, 'Compressed backup'),
+      createGunzip(),
+      byteLimit(MAX_EXPANDED_BYTES, 'Expanded backup'),
+      createWriteStream(tarPath, { mode: 0o600 })
+    );
+    const importedFiles = await extractTar(tarPath, stagingDirectory);
+    await mergeDirectory(stagingDirectory, paths.dataDir);
+    res.json({
+      importedFiles,
+      ...(await dataDirectoryStats())
+    });
+  } catch (error) {
+    next(error);
+  } finally {
+    await rm(temporaryDirectory, { recursive: true, force: true }).catch(() => {});
+  }
+});
+
+export default router;

package/server/routes/file-organizer.js

@@ -16,8 +16,8 @@ router.post('/scan', async (req, res, next) => {
     const result = await scanFolder({
       sourcePath,
       targetPath,
-      includeSubfolders: Boolean(includeSubfolders),
-      skipOrganized: skipOrganized !== false
+      includeSubfolders: includeSubfolders === true || includeSubfolders === 'true',
+      skipOrganized: skipOrganized !== false && skipOrganized !== 'false'
     });
 
     res.json(result);

package/server/routes/jira-filters.js

@@ -112,6 +112,10 @@ router.get('/:id/issues', async (req, res) => {
     return res.status(404).json({ error: 'Filter not found.' });
   }
 
+  if (filter.mockIssues && Array.isArray(filter.mockIssues)) {
+    return res.json({ filter, issues: filter.mockIssues });
+  }
+
   const jiraHost = getJiraHost();
   if (!jiraHost) {
     return res.status(400).json({ error: 'Jira domain is not configured. Please set Domain in Settings.' });
@@ -121,7 +125,7 @@ router.get('/:id/issues', async (req, res) => {
   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 url = `https://${jiraHost}/rest/api/2/search?jql=filter%3D${encodeURIComponent(filter.filterId)}&maxResults=200&fields=summary,priority,duedate,status,issuetype`;
     const headers = {};
     if (token) {
       headers.Authorization = token.startsWith('Bearer ') ? token : `Bearer ${token}`;
@@ -144,6 +148,7 @@ router.get('/:id/issues', async (req, res) => {
         priority: fields.priority || null,
         dueDate: fields.duedate || null,
         status: fields.status?.name || null,
+        issueType: fields.issuetype?.name || null,
         url: `https://${jiraHost}/browse/${key}`
       };
     });
@@ -153,14 +158,14 @@ router.get('/:id/issues', async (req, res) => {
 
     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`;
+    const targetUrl = `https://${jiraHost}/rest/api/2/search?jql=filter%3D${encodeURIComponent(filter.filterId)}&maxResults=200&fields=summary,priority,duedate,status,issuetype`;
     res.status(500).json({ error: error.message || 'Failed to fetch Jira issues.', targetUrl });
   }
 });
 
 // Clone an issue
 router.post('/issues/clone', async (req, res) => {
-  const { issueKey, summary } = req.body || {};
+  const { issueKey, summary, issueType } = req.body || {};
   if (!summary || typeof summary !== 'string' || !summary.trim()) {
     return res.status(400).json({ error: 'Summary is required for clone.' });
   }
@@ -194,20 +199,78 @@ router.post('/issues/clone', async (req, res) => {
       // Ignore if fetching current user fails
     }
 
-    const projectKey = issueKey ? issueKey.split('-')[0] : '';
+    // Fetch original issue details to preserve issue type, project, description, priority
+    let origIssueType = null;
+    let origProjectKey = null;
+    let origDescription = null;
+    let origPriority = null;
+
+    if (issueKey) {
+      try {
+        const issueUrl = `https://${jiraHost}/rest/api/2/issue/${encodeURIComponent(issueKey)}`;
+        const origRes = await httpClient.get(issueUrl, { headers });
+        if (origRes.status === 200 && origRes.data?.fields) {
+          const fields = origRes.data.fields;
+          if (fields.issuetype) {
+            if (fields.issuetype.id) {
+              origIssueType = { id: fields.issuetype.id };
+            } else if (fields.issuetype.name) {
+              origIssueType = { name: fields.issuetype.name };
+            }
+          }
+          if (fields.project?.key) {
+            origProjectKey = fields.project.key;
+          }
+          if (fields.description) {
+            origDescription = fields.description;
+          }
+          if (fields.priority) {
+            if (fields.priority.id) {
+              origPriority = { id: fields.priority.id };
+            } else if (fields.priority.name) {
+              origPriority = { name: fields.priority.name };
+            }
+          }
+        }
+      } catch {
+        // Ignore if fetching original issue fails
+      }
+    }
+
+    // Determine issue type fallback: fetched original issueType -> passed issueType -> Task
+    const targetIssueType = origIssueType || (issueType ? { name: issueType } : { name: 'Task' });
+    const projectKey = origProjectKey || (issueKey ? issueKey.split('-')[0] : '');
     const url = `https://${jiraHost}/rest/api/2/issue`;
     const payload = {
       fields: {
         summary: summary.trim(),
         ...(projectKey ? { project: { key: projectKey } } : {}),
-        issuetype: { name: 'Task' },
-        ...(assigneeField ? { assignee: assigneeField } : {})
+        issuetype: targetIssueType,
+        ...(assigneeField ? { assignee: assigneeField } : {}),
+        ...(origDescription ? { description: origDescription } : {}),
+        ...(origPriority ? { priority: origPriority } : {})
       }
     };
 
-    const response = await httpClient.post(url, payload, { headers });
+    let response = await httpClient.post(url, payload, { headers });
+    // Fallback if optional fields like description or priority caused issue creation rejection
+    if (response.status !== 201 && response.status !== 200 && (origPriority || origDescription)) {
+      const fallbackPayload = {
+        fields: {
+          summary: summary.trim(),
+          ...(projectKey ? { project: { key: projectKey } } : {}),
+          issuetype: targetIssueType,
+          ...(assigneeField ? { assignee: assigneeField } : {})
+        }
+      };
+      response = await httpClient.post(url, fallbackPayload, { headers });
+    }
+
     if (response.status !== 201 && response.status !== 200) {
-      const errMsg = response.data?.errorMessages?.[0] || response.data?.message || `Jira API returned status ${response.status}`;
+      const errMsg = response.data?.errorMessages?.[0] ||
+        (response.data?.errors ? Object.values(response.data.errors).join(', ') : null) ||
+        response.data?.message ||
+        `Jira API returned status ${response.status}`;
       return res.status(response.status).json({ error: errMsg });
     }
 

package/server/routes/updates.js

@@ -0,0 +1,140 @@
+import { execFile } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+import { Router } from 'express';
+import { root } from '../config.js';
+
+const router = Router();
+const execFileAsync = promisify(execFile);
+const packageJson = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'));
+const PACKAGE_NAME = packageJson.name;
+const CURRENT_VERSION = packageJson.version;
+const CACHE_TTL_MS = 15 * 60 * 1000;
+
+let cachedResult = null;
+let cachedAt = 0;
+
+function versionParts(version) {
+  return String(version || '')
+    .trim()
+    .replace(/^v/i, '')
+    .split('-')[0]
+    .split('.')
+    .map((part) => Number.parseInt(part, 10) || 0);
+}
+
+function compareVersions(left, right) {
+  const a = versionParts(left);
+  const b = versionParts(right);
+  const length = Math.max(a.length, b.length);
+  for (let index = 0; index < length; index += 1) {
+    const difference = (a[index] || 0) - (b[index] || 0);
+    if (difference !== 0) return difference;
+  }
+  return 0;
+}
+
+function normalizeChangelogEntry(entry) {
+  if (!entry || typeof entry !== 'object' || !entry.version) return null;
+  return {
+    version: String(entry.version).replace(/^v/i, ''),
+    name: entry.name || 'Release',
+    notes: Array.isArray(entry.notes) ? entry.notes.map((note) => `• ${note}`).join('\n') : String(entry.notes || ''),
+    publishedAt: entry.publishedAt || null
+  };
+}
+
+function buildReleaseList(metadata) {
+  const localEntries = Array.isArray(packageJson.devbuddyChangelog)
+    ? packageJson.devbuddyChangelog.map(normalizeChangelogEntry).filter(Boolean)
+    : [];
+  const remoteEntries = Array.isArray(metadata.devbuddyChangelog)
+    ? metadata.devbuddyChangelog.map(normalizeChangelogEntry).filter(Boolean)
+    : [];
+  const entriesByVersion = new Map();
+
+  [...remoteEntries, ...localEntries].forEach((entry) => {
+    if (!entriesByVersion.has(entry.version)) entriesByVersion.set(entry.version, entry);
+  });
+
+  if (metadata.time && typeof metadata.time === 'object') {
+    Object.entries(metadata.time).forEach(([version, publishedAt]) => {
+      if (['created', 'modified'].includes(version) || !/^\d+\.\d+\.\d+/.test(version)) return;
+      const existing = entriesByVersion.get(version);
+      if (existing) {
+        if (!existing.publishedAt) existing.publishedAt = publishedAt;
+      } else {
+        entriesByVersion.set(version, {
+          version,
+          name: 'Release',
+          notes: 'Published to the configured npm registry.',
+          publishedAt
+        });
+      }
+    });
+  }
+
+  return [...entriesByVersion.values()]
+    .sort((left, right) => compareVersions(right.version, left.version))
+    .slice(0, 10);
+}
+
+async function readNpmPackageMetadata() {
+  const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+  const { stdout } = await execFileAsync(
+    npmCommand,
+    ['view', `${PACKAGE_NAME}@latest`, 'version', 'time', 'devbuddyChangelog', '--json'],
+    {
+      timeout: 8000,
+      maxBuffer: 1024 * 1024,
+      windowsHide: true
+    }
+  );
+  const metadata = JSON.parse(stdout);
+  if (!metadata || typeof metadata !== 'object' || !metadata.version) {
+    throw new Error('The configured npm registry did not return package version metadata.');
+  }
+  return metadata;
+}
+
+async function checkForUpdates() {
+  const metadata = await readNpmPackageMetadata();
+  const latestVersion = String(metadata.version).replace(/^v/i, '');
+  return {
+    currentVersion: CURRENT_VERSION,
+    latestVersion,
+    updateAvailable: compareVersions(latestVersion, CURRENT_VERSION) > 0,
+    checkedAt: new Date().toISOString(),
+    releases: buildReleaseList(metadata),
+    sourceUnavailable: false
+  };
+}
+
+function unavailableResult() {
+  return {
+    currentVersion: CURRENT_VERSION,
+    latestVersion: CURRENT_VERSION,
+    updateAvailable: false,
+    checkedAt: new Date().toISOString(),
+    releases: buildReleaseList({}),
+    sourceUnavailable: true
+  };
+}
+
+router.get('/', async (req, res) => {
+  const forceRefresh = req.query.refresh === '1';
+  if (!forceRefresh && cachedResult && Date.now() - cachedAt < CACHE_TTL_MS) {
+    return res.json(cachedResult);
+  }
+
+  try {
+    cachedResult = await checkForUpdates();
+  } catch {
+    cachedResult = unavailableResult();
+  }
+  cachedAt = Date.now();
+  return res.json(cachedResult);
+});
+
+export default router;

package/server.js

@@ -21,6 +21,8 @@ import postmanRoutes from './server/routes/postman.js';
 import bookmarkSyncRoutes from './server/routes/bookmark-sync.js';
 import fileOrganizerRoutes from './server/routes/file-organizer.js';
 import branchSyncRoutes from './server/routes/branch-sync.js';
+import updateRoutes from './server/routes/updates.js';
+import dataBackupRoutes from './server/routes/data-backup.js';
 import { addErrorRecord } from './server/repositories/errors.js';
 import { startClipboardCapture } from './server/services/clipboard-history.js';
 
@@ -77,6 +79,8 @@ app.use('/api/postman', postmanRoutes);
 app.use('/api/bookmark-sync', bookmarkSyncRoutes);
 app.use('/api/file-organizer', fileOrganizerRoutes);
 app.use('/api/branch-sync', branchSyncRoutes);
+app.use('/api/updates', updateRoutes);
+app.use('/api/data-backup', dataBackupRoutes);
 
 app.use((err, req, res, _next) => {
   addErrorRecord({