@boyingliu01/xp-gate 0.6.0 → 0.6.2

package/lib/__tests__/ui-review.test.ts

@@ -0,0 +1,119 @@
+/**
+ * @test ui-review
+ * @intent Verify UI review file generation helpers
+ * @covers UI-REVIEW-001
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { execSync } from 'child_process';
+import { existsSync, mkdirSync, readFileSync, rmSync } from 'fs';
+import { join } from 'path';
+
+vi.mock('child_process', () => ({
+  execSync: vi.fn(),
+}));
+
+const mockExecSync = vi.mocked(execSync);
+const TEST_DIR = join(process.cwd(), '.ui-review-test');
+
+describe('ui-review', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true, force: true });
+    }
+    mkdirSync(TEST_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true, force: true });
+    }
+  });
+
+  it('should parse file list and renamed paths', async () => {
+    const { parseFileList } = await import('../ui-review');
+    expect(parseFileList('views/a.html → views/b.html\n\nsrc/auth.ts\n')).toEqual([
+      'views/b.html',
+      'src/auth.ts',
+    ]);
+  });
+
+  it('should return changed files from staged and modified diff', async () => {
+    mockExecSync.mockReturnValue('src/components/Button.tsx\nviews/index.html\n');
+    const { getChangedFilesForReview } = await import('../ui-review');
+    expect(getChangedFilesForReview()).toEqual(['src/components/Button.tsx', 'views/index.html']);
+  });
+
+  it('should fall back to tracked files when no changes are present', async () => {
+    mockExecSync
+      .mockReturnValueOnce('')
+      .mockReturnValueOnce('src/components/Fallback.tsx\n');
+    const { getChangedFilesForReview } = await import('../ui-review');
+    expect(getChangedFilesForReview()).toEqual(['src/components/Fallback.tsx']);
+  });
+
+  it('should fall back to find command when git ls-files fails', async () => {
+    mockExecSync
+      .mockReturnValueOnce('')
+      .mockImplementationOnce(() => { throw new Error('not git'); })
+      .mockReturnValueOnce('views/index.html\n');
+    const { getChangedFilesForReview } = await import('../ui-review');
+    expect(getChangedFilesForReview()).toEqual(['views/index.html']);
+  });
+
+  it('should build an approved review result with 24h expiry', async () => {
+    mockExecSync.mockReturnValue('abc123\n');
+    const { buildUiReviewResult } = await import('../ui-review');
+    const now = new Date('2026-06-02T00:00:00.000Z');
+    const result = buildUiReviewResult(['views/index.html'], now);
+    expect(result).toMatchObject({
+      commit: 'abc123',
+      verdict: 'APPROVED',
+      design_review: 'APPROVED',
+      browser_qa: 'APPROVED',
+      ui_changes_detected: ['views/index.html'],
+    });
+    expect(result.expires).toBe('2026-06-03T00:00:00.000Z');
+  });
+
+  it('should run main and exit 0 when no UI changes are detected', async () => {
+    mockExecSync.mockReturnValue('src/auth.ts\n');
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as never);
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+    const { main } = await import('../ui-review');
+    main();
+    expect(exitSpy).toHaveBeenCalledWith(0);
+    expect(logSpy).toHaveBeenCalledWith('ℹ️ No UI changes detected in staged/modified files.');
+    exitSpy.mockRestore();
+    logSpy.mockRestore();
+  });
+
+  it('should run main and write result when UI changes are detected', async () => {
+    const cwdSpy = vi.spyOn(process, 'cwd').mockReturnValue(TEST_DIR);
+    mockExecSync
+      .mockReturnValueOnce('views/index.html\n')
+      .mockReturnValueOnce('abc123\n');
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+    const { main } = await import('../ui-review');
+    main();
+    expect(existsSync(join(TEST_DIR, '.ui-gate-result.json'))).toBe(true);
+    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Generated .ui-gate-result.json'));
+    cwdSpy.mockRestore();
+    logSpy.mockRestore();
+  });
+
+  it('should write .ui-gate-result.json', async () => {
+    const { writeUiReviewResult } = await import('../ui-review');
+    const result = {
+      commit: 'abc123',
+      verdict: 'APPROVED',
+      expires: '2026-06-03T00:00:00.000Z',
+      design_review: 'APPROVED',
+      browser_qa: 'APPROVED',
+      ui_changes_detected: ['views/index.html'],
+    };
+    writeUiReviewResult(result, TEST_DIR);
+    const parsed = JSON.parse(readFileSync(join(TEST_DIR, '.ui-gate-result.json'), 'utf8'));
+    expect(parsed.ui_changes_detected).toEqual(['views/index.html']);
+  });
+});

package/lib/__tests__/uninstall.test.js

@@ -27,6 +27,7 @@ describe('uninstall', () => {
     delete require.cache[require.resolve('../uninstall')];
     delete require.cache[require.resolve('../init')];
     delete require.cache[require.resolve('../detect-deps.js')];
+    delete require.cache[require.resolve('../shared-paths')];
     logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
     warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
     errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});

package/lib/detect-deps.js

@@ -3,20 +3,72 @@ const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
 
+const { HOME_DIR } = require('./shared-paths.js');
+
+const REQUIRED_DEPS = [
+  { name: 'superpowers', repo: 'obra/superpowers', minVersion: '1.0.0' },
+  { name: 'gstack', repo: 'garrytan/gstack', minVersion: '1.0.0' }
+];
+
 /**
- * Resolve the user's home directory cross-platform.
- * Fallback chain: HOME → USERPROFILE → os.homedir()
- * This covers all known Windows/Linux/macOS/edge cases.
+ * Platform profiles — each AI agent platform has its own skills directory.
+ * All platforms require the same dependencies (superpowers, gstack).
+ *
+ * @covers Issue #128 Bug 1 — Qoder platform was excluded from dependency checks
  */
-const HOME = process.env.HOME || process.env.USERPROFILE || os.homedir();
+const PLATFORM_PROFILES = {
+  opencode: {
+    skillsDirs: [
+      path.join(HOME_DIR, '.config', 'opencode', 'skills'),
+      path.join(HOME_DIR, '.config', 'opencode'),
+    ],
+    requiredDeps: REQUIRED_DEPS,
+  },
+  'claude-code': {
+    skillsDirs: [
+      path.join(HOME_DIR, '.claude', 'skills'),
+      path.join(HOME_DIR, '.claude'),
+    ],
+    requiredDeps: REQUIRED_DEPS,
+  },
+  qoder: {
+    skillsDirs: [
+      path.join(HOME_DIR, '.qoder', 'skills'),
+      path.join(HOME_DIR, '.qoder'),
+    ],
+    requiredDeps: REQUIRED_DEPS,
+  },
+};
 
-const SKILLS_DIR = path.join(HOME, '.config', 'opencode', 'skills');
-const OPENCODE_DIR = path.join(HOME, '.config', 'opencode');
+/**
+ * Detect which AI agent platform is currently in use.
+ * Checks for platform-specific directories in the user's home.
+ * Falls back to 'opencode' if no platform is detected.
+ *
+ * @returns {'opencode' | 'claude-code' | 'qoder'}
+ */
+function detectPlatform() {
+  // Check for Qoder-specific marker
+  if (fs.existsSync(path.join(HOME_DIR, '.qoder', 'skills'))) {
+    return 'qoder';
+  }
+  // Check for Claude Code-specific marker
+  if (fs.existsSync(path.join(HOME_DIR, '.claude', 'skills'))) {
+    return 'claude-code';
+  }
+  // Default to opencode (most common, backward compatible)
+  return 'opencode';
+}
 
-const REQUIRED_DEPS = [
-  { name: 'superpowers', minVersion: '1.0.0' },
-  { name: 'gstack', minVersion: '1.0.0' }
-];
+/**
+ * Get the skills directories for a given platform.
+ * @param {string} platform - 'opencode' | 'claude-code' | 'qoder'
+ * @returns {string[]}
+ */
+function getSkillsDirs(platform) {
+  const profile = PLATFORM_PROFILES[platform] || PLATFORM_PROFILES.opencode;
+  return profile.skillsDirs;
+}
 
 /**
  * Check if bash is available on the system.
@@ -84,25 +136,28 @@ function checkBash() {
   }
 }
 
-async function checkDeps() {
+/**
+ * Check if required dependencies are installed for the given platform.
+ * @param {string} [platform='opencode'] - AI agent platform
+ * @returns {Promise<{ok: boolean, missing?: string, versionMismatch?: object}>}
+ */
+async function checkDeps(platform = 'opencode') {
+  const skillsDirs = getSkillsDirs(platform);
+
   for (const dep of REQUIRED_DEPS) {
-    const possiblePaths = [
-      path.join(SKILLS_DIR, dep.name),
-      path.join(OPENCODE_DIR, dep.name)
-    ];
-    
     let depDir = null;
-    for (const p of possiblePaths) {
-      if (fs.existsSync(p)) {
-        depDir = p;
+    for (const baseDir of skillsDirs) {
+      const candidate = path.join(baseDir, dep.name);
+      if (fs.existsSync(candidate)) {
+        depDir = candidate;
         break;
       }
     }
-    
+
     if (!depDir) {
       return { ok: false, missing: dep.name };
     }
-    
+
     const version = await getSkillVersion(depDir);
     if (version && compareVersions(version, dep.minVersion) < 0) {
       return {
@@ -115,10 +170,101 @@ async function checkDeps() {
       };
     }
   }
-  
+
   return { ok: true };
 }
 
+/**
+ * Auto-install missing dependencies by cloning from GitHub.
+ * @param {string} [platform='opencode'] - AI agent platform
+ * @returns {Promise<{ok: boolean, installed?: string[], errors?: Array<{name: string, message: string}>}>}
+ */
+async function autoInstallDeps(platform = 'opencode') {
+  const skillsDirs = getSkillsDirs(platform);
+  const targetDir = skillsDirs[0]; // Install to the primary skills directory
+
+  if (!fs.existsSync(targetDir)) {
+    try {
+      fs.mkdirSync(targetDir, { recursive: true });
+    } catch (e) {
+      return {
+        ok: false,
+        errors: [{ name: 'mkdir', message: `Cannot create skills directory: ${e.message}` }]
+      };
+    }
+  }
+
+  const check = await checkDeps(platform);
+  if (check.ok) {
+    return { ok: true, installed: [] };
+  }
+
+  const errors = [];
+  const installed = [];
+
+  // Check each dep: missing → install, version mismatch → can't auto-fix
+  const depCheck = await checkDeps(platform);
+  if (depCheck.ok) {
+    return { ok: true, installed: [] };
+  }
+
+  // If the issue is version mismatch, auto-install can't help
+  if (depCheck.versionMismatch) {
+    return {
+      ok: false,
+      installed: [],
+      errors: [{
+        name: depCheck.versionMismatch.name,
+        message: `version mismatch: need ${depCheck.versionMismatch.required}, found ${depCheck.versionMismatch.found} (auto-install cannot upgrade)`
+      }]
+    };
+  }
+
+  for (const dep of REQUIRED_DEPS) {
+    // Re-check if this specific dep is missing
+    let exists = false;
+    for (const baseDir of skillsDirs) {
+      if (fs.existsSync(path.join(baseDir, dep.name))) {
+        exists = true;
+        break;
+      }
+    }
+    if (exists) continue;
+
+    const destPath = path.join(targetDir, dep.name);
+    const repoUrl = `https://github.com/${dep.repo}.git`;
+
+    try {
+      console.log(`  ${dep.name}: not found → installing from ${repoUrl} ...`);
+      const cp = require('child_process');
+      cp.execSync(`git clone --depth 1 "${repoUrl}" "${destPath}"`, {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+        timeout: 120000, // 2 minute timeout
+      });
+      installed.push(dep.name);
+      console.log(`  ${dep.name}: OK`);
+    } catch (e) {
+      errors.push({ name: dep.name, message: e.message || 'git clone failed' });
+      console.warn(`  ${dep.name}: FAILED (${e.message || 'unknown error'})`);
+      // Clean up partial clone
+      try {
+        if (fs.existsSync(destPath)) {
+          fs.rmSync(destPath, { recursive: true, force: true });
+        }
+      } catch {
+        // Ignore cleanup failures
+      }
+    }
+  }
+
+  if (errors.length > 0) {
+    return { ok: false, installed, errors };
+  }
+
+  return { ok: true, installed };
+}
+
 async function getSkillVersion(skillDir) {
   const pkgFile = path.join(skillDir, 'package.json');
   if (fs.existsSync(pkgFile)) {
@@ -127,7 +273,7 @@ async function getSkillVersion(skillDir) {
       return pkg.version;
     } catch {}
   }
-  
+
   const skillFile = path.join(skillDir, 'SKILL.md');
   if (fs.existsSync(skillFile)) {
     const content = fs.readFileSync(skillFile, 'utf8');
@@ -136,22 +282,30 @@ async function getSkillVersion(skillDir) {
       return versionMatch[1];
     }
   }
-  
+
   return null;
 }
 
 function compareVersions(a, b) {
   const partsA = a.split('.').map(Number);
   const partsB = b.split('.').map(Number);
-  
+
   for (let i = 0; i < 3; i++) {
     const partA = partsA[i] || 0;
     const partB = partsB[i] || 0;
     if (partA > partB) return 1;
     if (partA < partB) return -1;
   }
-  
+
   return 0;
 }
 
-module.exports = { checkDeps, checkBash };
+module.exports = {
+  checkDeps,
+  checkBash,
+  autoInstallDeps,
+  detectPlatform,
+  getSkillsDirs,
+  PLATFORM_PROFILES,
+  REQUIRED_DEPS,
+};

package/lib/doctor.js

@@ -1,15 +1,13 @@
 const fs = require('fs');
 const path = require('path');
-const os = require('os');
 const { execSync } = require('child_process');
-
-// Cross-platform home directory resolution
-const HOME_DIR = process.env.HOME || process.env.USERPROFILE || os.homedir();
-
-const CONFIG_DIR = path.join(HOME_DIR, '.config', 'xp-gate');
-const CONFIG_FILE = path.join(CONFIG_DIR, 'xp-gate.json');
-const GLOBAL_HOOKS_DIR = path.join(CONFIG_DIR, 'hooks');
-const GLOBAL_ADAPTERS_DIR = path.join(CONFIG_DIR, 'adapters');
+const {
+  HOME_DIR,
+  CONFIG_DIR,
+  CONFIG_FILE,
+  GLOBAL_HOOKS_DIR,
+  GLOBAL_ADAPTERS_DIR,
+} = require('./shared-paths.js');
 
 // npm package source dir (template hooks/adapters)
 const PKG_DIR = path.dirname(__dirname);

package/lib/gate-audit.ts

@@ -177,64 +177,44 @@ export function computeStats(
  * Renames current file to .1, shifts existing archives.
  * Keeps at most MAX_ARCHIVES archived files.
  */
-export function rotateIfNeeded(logPath: string): void {
-  if (!existsSync(logPath)) {
-    return;
-  }
-
-  let stats;
+function shouldRotate(logPath: string): boolean {
+  if (!existsSync(logPath)) return false;
   try {
-    stats = statSync(logPath);
+    return statSync(logPath).size >= MAX_FILE_BYTES;
   } catch {
-    return;
-  }
-
-  if (stats.size < MAX_FILE_BYTES) {
-    return;
+    return false;
   }
+}
 
-  // Shift archives: .2 -> .3, .1 -> .2
+function shiftOldArchives(logPath: string): void {
   for (let i = MAX_ARCHIVES; i >= 2; i--) {
     const from = `${logPath}.${i - 1}`;
     const to = `${logPath}.${i}`;
     if (existsSync(from)) {
-      try {
-        renameSync(from, to);
-      } catch {
-        // Race condition or permission issue — skip
-      }
+      try { renameSync(from, to); } catch { /* skip */ }
     }
   }
+}
 
-  // Current -> .1
-  const firstArchive = `${logPath}.1`;
-  if (existsSync(firstArchive)) {
-    try {
-      renameSync(firstArchive, `${logPath}.2`);
-    } catch {
-      // Skip on error
-    }
+function archiveCurrent(logPath: string): void {
+  const first = `${logPath}.1`;
+  if (existsSync(first)) {
+    try { renameSync(first, `${logPath}.2`); } catch { /* skip */ }
   }
-
   try {
-    renameSync(logPath, firstArchive);
+    renameSync(logPath, first);
   } catch {
-    // If rename fails, truncate the current file instead
-    try {
-      writeFileSync(logPath, '', 'utf8');
-    } catch {
-      console.error('[xp-gate audit] Failed to rotate or truncate log:', logPath);
-    }
+    try { writeFileSync(logPath, '', 'utf8'); } catch { /* skip */ }
   }
 }
 
-// ── CLI entry point (direct invocation from hooks) ───────────────────────────
+export function rotateIfNeeded(logPath: string): void {
+  if (!shouldRotate(logPath)) return;
+  shiftOldArchives(logPath);
+  archiveCurrent(logPath);
+}
 
-/**
- * When called directly via `npx tsx gate-audit.ts record --gate-id ...`,
- * this block handles CLI argument parsing and appends the entry.
- */
-if (require.main === module) {
+function runCli(): void {
   const args = process.argv.slice(2);
   const command = args[0];
 
@@ -258,7 +238,11 @@ if (require.main === module) {
   }
 }
 
-function parseCliOptions(args: string[]): Record<string, string> {
+if (require.main === module) {
+  runCli();
+}
+
+export function parseCliOptions(args: string[]): Record<string, string> {
   const opts: Record<string, string> = {};
   for (let i = 0; i < args.length; i++) {
     if (args[i].startsWith('--') && i + 1 < args.length) {
@@ -269,7 +253,7 @@ function parseCliOptions(args: string[]): Record<string, string> {
   return opts;
 }
 
-function getCommitHash(): string {
+export function getCommitHash(): string {
   try {
     const { execSync } = require('child_process');
     return execSync('git rev-parse HEAD', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();

package/lib/init.js

@@ -1,18 +1,15 @@
 const fs = require('fs');
 const path = require('path');
-const os = require('os');
 const crypto = require('crypto');
-const { checkDeps } = require('./detect-deps.js');
-const { checkBash } = require('./detect-deps.js');
-
-// Cross-platform home directory resolution with os.homedir() fallback
-const HOME_DIR = process.env.HOME || process.env.USERPROFILE || os.homedir();
-
-const CONFIG_DIR = path.join(HOME_DIR, '.config', 'xp-gate');
-const CONFIG_FILE = path.join(CONFIG_DIR, 'xp-gate.json');
-const TEMPLATE_DIR = path.join(HOME_DIR, '.config', 'opencode', 'git-hooks-template');
-const GLOBAL_HOOKS_DIR = path.join(CONFIG_DIR, 'hooks');
-const GLOBAL_ADAPTERS_DIR = path.join(CONFIG_DIR, 'adapters');
+const { checkDeps, checkBash, autoInstallDeps, detectPlatform } = require('./detect-deps.js');
+const {
+  HOME_DIR,
+  CONFIG_DIR,
+  CONFIG_FILE,
+  TEMPLATE_DIR,
+  GLOBAL_HOOKS_DIR,
+  GLOBAL_ADAPTERS_DIR,
+} = require('./shared-paths.js');
 
 function copyHooks(srcDir, destDir) {
   ['pre-commit', 'pre-push'].forEach(hook => {
@@ -54,6 +51,35 @@ function logDeps(depCheck) {
   }
 }
 
+/**
+ * Detect which AI agent platform is in use and check/auto-install deps.
+ * @param {string} platform - 'opencode' | 'claude-code' | 'qoder'
+ */
+async function checkAndInstallDeps(platform) {
+  const depCheck = await checkDeps(platform);
+  if (depCheck.ok) {
+    logDeps(depCheck);
+    return depCheck;
+  }
+
+  // Auto-install missing deps
+  console.log(`Checking dependencies (platform: ${platform})...`);
+  const installResult = await autoInstallDeps(platform);
+  if (installResult.ok) {
+    console.log('Dependencies: OK (auto-installed)\n');
+    return { ok: true };
+  }
+
+  // Auto-install failed — report and continue with warning
+  logDeps(depCheck);
+  if (installResult.errors) {
+    for (const err of installResult.errors) {
+      console.warn(`  Auto-install failed for ${err.name}: ${err.message}`);
+    }
+  }
+  return depCheck;
+}
+
 function printUsage() {
   console.log('Choose installation mode:');
   console.log('  1) Global  — all git projects use the same hooks (recommended)');
@@ -228,7 +254,10 @@ async function init(args) {
     console.warn(`  ${bashCheck.message}\n`);
   }
 
-  logDeps(await checkDeps());
+  // Detect platform and check/auto-install dependencies
+  const platform = detectPlatform();
+  console.log(`Platform: ${platform}\n`);
+  await checkAndInstallDeps(platform);
 
   const installMode = args.includes('--global') ? 'global' :
                       args.includes('--core-only') ? 'local' :

package/lib/install-skill.js

@@ -1,18 +1,14 @@
 const fs = require('fs');
 const path = require('path');
-const os = require('os');
 const https = require('https');
 const http = require('http');
 const { execSync } = require('child_process');
-const { checkDeps } = require('./detect-deps.js');
+const { checkDeps, detectPlatform } = require('./detect-deps.js');
 const { downloadFromGitHub } = require('./download-skill.js');
 const { rollback } = require('./rollback.js');
+const { HOME_DIR, CONFIG_DIR } = require('./shared-paths.js');
 
-// Cross-platform home directory resolution
-const HOME = process.env.HOME || process.env.USERPROFILE || os.homedir();
-
-const CONFIG_DIR = path.join(HOME, '.config', 'xp-gate');
-const SKILLS_DIR = path.join(HOME, '.config', 'opencode', 'skills');
+const SKILLS_DIR = path.join(HOME_DIR, '.config', 'opencode', 'skills');
 
 const SKILLS_REGISTRY = {
   'sprint-flow': { repo: 'boyingliu01/xp-gate', path: 'skills/sprint-flow' },
@@ -24,7 +20,8 @@ const SKILLS_REGISTRY = {
 async function installSkill(name, options = {}) {
   const { offline = false, verbose = false, force = false } = options;
   
-  const depCheck = await checkDeps();
+  const platform = detectPlatform();
+  const depCheck = await checkDeps(platform);
   if (!depCheck.ok) {
     if (depCheck.missing) {
       console.error(`Error: ${depCheck.missing} is required but not installed`);
@@ -144,21 +141,7 @@ async function downloadFile(url, dest, verbose) {
   });
 }
 
-function copyDirRecursive(src, dest) {
-  fs.mkdirSync(dest, { recursive: true });
-  const entries = fs.readdirSync(src, { withFileTypes: true });
-  
-  for (const entry of entries) {
-    const srcPath = path.join(src, entry.name);
-    const destPath = path.join(dest, entry.name);
-    
-    if (entry.isDirectory()) {
-      copyDirRecursive(srcPath, destPath);
-    } else {
-      fs.copyFileSync(srcPath, destPath);
-    }
-  }
-}
+const { copyDirRecursive } = require('./shared-utils');
 
 function ensureConfigDir() {
   fs.mkdirSync(CONFIG_DIR, { recursive: true });

package/lib/rollback.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { copyDirRecursive } = require('./shared-utils');
 
 // Cross-platform home directory resolution
 const HOME = process.env.HOME || process.env.USERPROFILE || os.homedir();
@@ -51,22 +52,6 @@ async function createBackup(installId, skillName) {
   return backupDir;
 }
 
-function copyDirRecursive(src, dest) {
-  fs.mkdirSync(dest, { recursive: true });
-  const entries = fs.readdirSync(src, { withFileTypes: true });
-  
-  for (const entry of entries) {
-    const srcPath = path.join(src, entry.name);
-    const destPath = path.join(dest, entry.name);
-    
-    if (entry.isDirectory()) {
-      copyDirRecursive(srcPath, destPath);
-    } else {
-      fs.copyFileSync(srcPath, destPath);
-    }
-  }
-}
-
 function cleanupBackup(installId) {
   const backupDir = path.join(BACKUP_DIR, installId);