pi-var 1.0.1

package/extensions/pi-var/src/cow/detection.ts

@@ -0,0 +1,215 @@
+/**
+ * Copy-on-Write detection and performance testing
+ */
+
+import { exec, execSync } from 'child_process';
+import { promisify } from 'util';
+import * as os from 'os';
+import * as path from 'path';
+import { promises as fs } from 'fs';
+import type { CoWDetectionResult, EDRDetectionResult } from '../types/index';
+import { detectEDR, detectCrowdStrike, hasSlowCoWEDR } from '../edr/index';
+
+const execAsync = promisify(exec);
+
+/**
+ * Detect Copy-on-Write support on the current platform
+ * Tests actual CoW functionality by creating test files
+ * Includes EDR detection and multi-iteration performance testing
+ *
+ * Strategy:
+ * 1. Known slow EDR detected (CrowdStrike, SentinelOne, etc.) → worktree
+ * 2. No slow EDR detected + fast CoW timing → cow
+ * 3. Uncertain cases → worktree (conservative)
+ */
+export async function detectCoWSupport(testDir: string): Promise<CoWDetectionResult> {
+  // Ensure test directory exists
+  await fs.mkdir(testDir, { recursive: true });
+
+  const testFile = path.join(testDir, `.cow-test-${Date.now()}`);
+  const clonedFile = path.join(testDir, `.cow-clone-${Date.now()}`);
+
+  // Detect EDR software that may impact CoW performance
+  let edrResult: CoWDetectionResult['edr'] = {
+    detected: false,
+    products: [],
+    hasSlowCoWEDR: false,
+  };
+  let hasCrowdStrike = false;
+
+  try {
+    const [edrDetection, crowdstrikeDetection] = await Promise.all([
+      detectEDR(),
+      detectCrowdStrike(),
+    ]);
+
+    hasCrowdStrike = crowdstrikeDetection;
+    edrResult = {
+      detected: edrDetection.detected,
+      products: edrDetection.details.map((d) => d.product),
+      hasSlowCoWEDR: hasSlowCoWEDR(edrDetection) || hasCrowdStrike,
+    };
+  } catch {
+    // EDR detection failed, continue without EDR info
+  }
+
+  // If we detected a known slow CoW EDR, we can short-circuit to worktree
+  // without needing timing validation (high confidence)
+  if (edrResult.hasSlowCoWEDR) {
+    return {
+      supported: true, // CoW technically works, just slow
+      edr: edrResult,
+      recommendedType: 'worktree',
+    };
+  }
+
+  try {
+    const platform = os.platform();
+
+    // Skip CoW detection entirely on Windows (no native CoW support)
+    if (platform === 'win32') {
+      return {
+        supported: false,
+        edr: edrResult,
+        recommendedType: 'worktree',
+      };
+    }
+
+    // Create test files of varying sizes
+    // Larger files more likely to trigger EDR scanning
+    const testSizes = [1 * 1024 * 1024, 5 * 1024 * 1024]; // 1MB and 5MB
+    let cowSupported = false;
+    let cowMethod: 'clonefile' | 'reflink' | undefined;
+    const timings: number[] = [];
+
+    for (const size of testSizes) {
+      const dataFile = `${testFile}-${size}`;
+      const cloneTarget = `${clonedFile}-${size}`;
+
+      try {
+        const testData = Buffer.alloc(size, 'x');
+        await fs.writeFile(dataFile, testData);
+
+        if (platform === 'darwin') {
+          // macOS: Try cp -c (clonefile)
+          const startTime = performance.now();
+          await execAsync(`cp -c "${dataFile}" "${cloneTarget}"`);
+          const duration = performance.now() - startTime;
+          timings.push(duration);
+
+          const [origStat, cloneStat] = await Promise.all([
+            fs.stat(dataFile),
+            fs.stat(cloneTarget),
+          ]);
+
+          if (origStat.size === cloneStat.size) {
+            cowSupported = true;
+            cowMethod = 'clonefile';
+          }
+        } else if (platform === 'linux') {
+          // Linux: Try cp --reflink=auto
+          const startTime = performance.now();
+          await execAsync(`cp -a --reflink=auto "${dataFile}" "${cloneTarget}"`);
+          const duration = performance.now() - startTime;
+          timings.push(duration);
+
+          const [origStat, cloneStat] = await Promise.all([
+            fs.stat(dataFile),
+            fs.stat(cloneTarget),
+          ]);
+
+          if (origStat.ino === cloneStat.ino) {
+            cowSupported = true;
+            cowMethod = 'reflink';
+          } else {
+            // Check filesystem type
+            try {
+              const { stdout } = await execAsync(`findmnt -T "${testDir}" -o FSTYPE --noheadings`);
+              const fsType = stdout.trim();
+              if (fsType === 'btrfs' || fsType.includes('xfs')) {
+                cowSupported = true;
+                cowMethod = 'reflink';
+              }
+            } catch {
+              // findmnt failed
+            }
+          }
+        }
+
+        // Cleanup this iteration's files
+        await fs.unlink(dataFile).catch(() => {});
+        await fs.unlink(cloneTarget).catch(() => {});
+      } catch {
+        // This size test failed, continue to next
+      }
+    }
+
+    // Analyze timing results
+    const avgTiming = timings.length > 0 ? timings.reduce((a, b) => a + b, 0) / timings.length : 0;
+    const maxTiming = timings.length > 0 ? Math.max(...timings) : 0;
+
+    // Conservative thresholds:
+    // - < 20ms: Definitely fast (no EDR interference)
+    // - 20-100ms: Uncertain (might be EDR, might be system load)
+    // - > 100ms: Definitely slow (likely EDR or very slow system)
+    const fastThreshold = 20;
+    const slowThreshold = 100;
+
+    let cowFast: boolean;
+    let confidence: 'high' | 'medium' | 'low';
+
+    if (avgTiming < fastThreshold) {
+      cowFast = true;
+      confidence = 'high';
+    } else if (avgTiming > slowThreshold) {
+      cowFast = false;
+      confidence = 'high';
+    } else {
+      // Gray zone - medium confidence
+      cowFast = false;
+      confidence = 'medium';
+    }
+
+    // Additional heuristics for gray zone:
+    // If max timing is significantly higher than average, might be intermittent EDR
+    const hasSpike = maxTiming > avgTiming * 3 && maxTiming > slowThreshold;
+
+    // Decision logic - priority order matters!
+    let recommendedType: 'cow' | 'worktree' | 'copy';
+
+    if (!cowSupported) {
+      recommendedType = 'worktree';
+    } else if (hasSpike || confidence === 'medium') {
+      // Uncertain or saw spikes - be conservative with worktree
+      // This check MUST come before the fast+high check to catch spikes
+      recommendedType = 'worktree';
+    } else if (cowFast && confidence === 'high') {
+      // Fast and confident - use CoW
+      recommendedType = 'cow';
+    } else {
+      // Slow but confident - definitely worktree
+      recommendedType = 'worktree';
+    }
+
+    return {
+      supported: cowSupported,
+      method: cowMethod,
+      edr: edrResult,
+      performance: {
+        fast: cowFast,
+        durationMs: avgTiming,
+        samples: timings.length,
+        maxDurationMs: maxTiming,
+        confidence,
+      },
+      recommendedType,
+    };
+  } catch {
+    // CoW detection failed entirely
+    return {
+      supported: false,
+      edr: edrResult,
+      recommendedType: 'worktree',
+    };
+  }
+}

package/extensions/pi-var/src/cow/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Copy-on-Write (CoW) module
+ * Exports CoW detection functionality
+ */
+
+export { detectCoWSupport } from './detection';

package/extensions/pi-var/src/edr/constants.ts

@@ -0,0 +1,199 @@
+/**
+ * EDR (Endpoint Detection and Response) constants
+ */
+
+/**
+ * Known EDR/AV process names by platform
+ */
+export const EDR_PROCESSES: Record<string, string[]> = {
+  darwin: [
+    'Falcon', // CrowdStrike Falcon
+    'falconctl', // CrowdStrike CLI
+    'SentinelAgent', // SentinelOne
+    'SentinelOne', // SentinelOne alternative
+    'CylanceSvc', // Cylance
+    'CylanceUI', // Cylance UI
+    'eset_daemon', // ESET
+    'eset_nod32', // ESET NOD32
+    'kav', // Kaspersky
+    'kaspersky', // Kaspersky
+    'SophosScanD', // Sophos
+    'SophosMRT', // Sophos MRT
+    'sophosscan', // Sophos
+    'com.symantec.nfm', // Symantec/Norton
+    'norton', // Norton
+    'mcshield', // McAfee
+    'McAfee', // McAfee
+    '的趋势', // Trend Micro (UTF-8)
+    'TrendMicro', // Trend Micro
+    'tmux', // Trend Micro
+    'CbDefense', // Carbon Black/VMware
+    'cbdaemon', // Carbon Black daemon
+    'xagt', // FireEye/XAGENT
+    'osqueryd', // osquery (often used for EDR)
+    'elastic-agent', // Elastic Security
+    'elastic-endpoint', // Elastic Endpoint
+    'jamf', // Jamf (MDM+security)
+    'defense', // Apple XProtect
+    'RTProtectionDaemon', // Various macOS AV
+  ],
+  linux: [
+    'falcon-sensor', // CrowdStrike Falcon
+    'falconctl', // CrowdStrike CLI
+    'sentinel-agent', // SentinelOne
+    'sentinelone', // SentinelOne alternative
+    'cylancesvc', // Cylance
+    'cylanceui', // Cylance UI
+    'eset_daemon', // ESET
+    'klnagent', // Kaspersky
+    'kav', // Kaspersky
+    'savscand', // Sophos
+    'sophos', // Sophos
+    'nscd', // Symantec
+    'symcscan', // Symantec
+    'mcshield', // McAfee
+    'nailsd', // McAfee Linux
+    'TrendMicro', // Trend Micro
+    'ds_agent', // Trend Micro Deep Security
+    'cbdaemon', // Carbon Black
+    'xagt', // FireEye
+    'osqueryd', // osquery
+    'elastic-agent', // Elastic Security
+    'elastic-endpoint', // Elastic Endpoint
+    'filebeat', // Elastic Filebeat (often used with security)
+    'auditd', // Linux audit daemon (security monitoring)
+    'apparmor', // AppArmor
+    'selinux', // SELinux userspace tools
+    'clamd', // ClamAV
+    'freshclam', // ClamAV updater
+  ],
+  win32: [
+    'CSAgent', // CrowdStrike (csagent service)
+    'CSFalconService', // CrowdStrike service
+    'SentinelAgent', // SentinelOne
+    'SentinelServiceHost', // SentinelOne service
+    'CylanceSvc', // Cylance
+    'CylanceUI', // Cylance UI
+    'ekrn', // ESET
+    'avp', // Kaspersky
+    'avpui', // Kaspersky UI
+    'avps', // Kaspersky service
+    'SavService', // Sophos
+    'SophosSafestore64', // Sophos
+    'SymCorpUI', // Symantec
+    'ccSvcHst', // Symantec service
+    'mcshield', // McAfee
+    'ModuleCoreService', // McAfee
+    'mcsvc', // McAfee
+    'TmListen', // Trend Micro
+    'TmProxy', // Trend Micro
+    'TmCCSF', // Trend Micro
+    'CbDefense', // Carbon Black
+    'repwx', // Carbon Black
+    'xagt', // FireEye
+    'osqueryd', // osquery
+    'elastic-agent', // Elastic Security
+    'elastic-endpoint', // Elastic Endpoint
+    'MsMpEng', // Microsoft Defender
+    'MsSense', // Microsoft Defender for Endpoint
+    'Sense', // Microsoft Defender for Endpoint
+    'WdFilter', // Windows Defender filter driver
+    'clamav', // ClamAV
+    'ImmunetProtect', // Cisco Immunet
+    'cyserver', // Cylance
+  ],
+};
+
+// Mapping of process names to product names and CoW impact
+export const EDR_INFO: Record<string, { product: string; knownSlowCoW: boolean }> = {
+  // CrowdStrike - major CoW impact
+  Falcon: { product: 'CrowdStrike Falcon', knownSlowCoW: true },
+  falconctl: { product: 'CrowdStrike Falcon', knownSlowCoW: true },
+  'falcon-sensor': { product: 'CrowdStrike Falcon', knownSlowCoW: true },
+  CSAgent: { product: 'CrowdStrike Falcon', knownSlowCoW: true },
+  CSFalconService: { product: 'CrowdStrike Falcon', knownSlowCoW: true },
+
+  // SentinelOne - major CoW impact
+  SentinelAgent: { product: 'SentinelOne', knownSlowCoW: true },
+  SentinelOne: { product: 'SentinelOne', knownSlowCoW: true },
+  SentinelServiceHost: { product: 'SentinelOne', knownSlowCoW: true },
+  'sentinel-agent': { product: 'SentinelOne', knownSlowCoW: true },
+  sentinelone: { product: 'SentinelOne', knownSlowCoW: true },
+
+  // Cylance - moderate to high CoW impact
+  CylanceSvc: { product: 'Cylance', knownSlowCoW: true },
+  CylanceUI: { product: 'Cylance', knownSlowCoW: true },
+  cylancesvc: { product: 'Cylance', knownSlowCoW: true },
+  cylanceui: { product: 'Cylance', knownSlowCoW: true },
+  cyserver: { product: 'Cylance', knownSlowCoW: true },
+
+  // Carbon Black - moderate CoW impact
+  CbDefense: { product: 'Carbon Black/VMware', knownSlowCoW: true },
+  cbdaemon: { product: 'Carbon Black/VMware', knownSlowCoW: true },
+  repwx: { product: 'Carbon Black/VMware', knownSlowCoW: true },
+
+  // Microsoft Defender for Endpoint - moderate CoW impact
+  MsSense: { product: 'Microsoft Defender for Endpoint', knownSlowCoW: true },
+  Sense: { product: 'Microsoft Defender for Endpoint', knownSlowCoW: true },
+
+  // FireEye - high CoW impact
+  xagt: { product: 'FireEye/XAGENT', knownSlowCoW: true },
+
+  // Traditional AV - generally lower CoW impact but still present
+  eset_daemon: { product: 'ESET', knownSlowCoW: false },
+  eset_nod32: { product: 'ESET', knownSlowCoW: false },
+  ekrn: { product: 'ESET', knownSlowCoW: false },
+  kav: { product: 'Kaspersky', knownSlowCoW: false },
+  kaspersky: { product: 'Kaspersky', knownSlowCoW: false },
+  klnagent: { product: 'Kaspersky', knownSlowCoW: false },
+  avp: { product: 'Kaspersky', knownSlowCoW: false },
+  avpui: { product: 'Kaspersky', knownSlowCoW: false },
+  avps: { product: 'Kaspersky', knownSlowCoW: false },
+  SophosScanD: { product: 'Sophos', knownSlowCoW: false },
+  SophosMRT: { product: 'Sophos', knownSlowCoW: false },
+  sophosscan: { product: 'Sophos', knownSlowCoW: false },
+  savscand: { product: 'Sophos', knownSlowCoW: false },
+  sophos: { product: 'Sophos', knownSlowCoW: false },
+  SavService: { product: 'Sophos', knownSlowCoW: false },
+  SophosSafestore64: { product: 'Sophos', knownSlowCoW: false },
+  'com.symantec.nfm': { product: 'Symantec/Norton', knownSlowCoW: false },
+  norton: { product: 'Symantec/Norton', knownSlowCoW: false },
+  SymCorpUI: { product: 'Symantec', knownSlowCoW: false },
+  ccSvcHst: { product: 'Symantec', knownSlowCoW: false },
+  nscd: { product: 'Symantec', knownSlowCoW: false },
+  symcscan: { product: 'Symantec', knownSlowCoW: false },
+  mcshield: { product: 'McAfee', knownSlowCoW: false },
+  mcsvc: { product: 'McAfee', knownSlowCoW: false },
+  ModuleCoreService: { product: 'McAfee', knownSlowCoW: false },
+  nailsd: { product: 'McAfee', knownSlowCoW: false },
+  的趋势: { product: 'Trend Micro', knownSlowCoW: false },
+  TrendMicro: { product: 'Trend Micro', knownSlowCoW: false },
+  tmux: { product: 'Trend Micro', knownSlowCoW: false },
+  ds_agent: { product: 'Trend Micro Deep Security', knownSlowCoW: false },
+  TmListen: { product: 'Trend Micro', knownSlowCoW: false },
+  TmProxy: { product: 'Trend Micro', knownSlowCoW: false },
+  TmCCSF: { product: 'Trend Micro', knownSlowCoW: false },
+
+  // Microsoft Defender (standard) - generally lower impact
+  MsMpEng: { product: 'Microsoft Defender', knownSlowCoW: false },
+  WdFilter: { product: 'Windows Defender', knownSlowCoW: false },
+
+  // Open source/enterprise tools - variable impact
+  osqueryd: { product: 'osquery', knownSlowCoW: false },
+  'elastic-agent': { product: 'Elastic Security', knownSlowCoW: false },
+  'elastic-endpoint': { product: 'Elastic Security', knownSlowCoW: false },
+  filebeat: { product: 'Elastic Filebeat', knownSlowCoW: false },
+  clamd: { product: 'ClamAV', knownSlowCoW: false },
+  freshclam: { product: 'ClamAV', knownSlowCoW: false },
+  ImmunetProtect: { product: 'Cisco Immunet', knownSlowCoW: false },
+
+  // Linux security tools
+  auditd: { product: 'Linux audit daemon', knownSlowCoW: false },
+  apparmor: { product: 'AppArmor', knownSlowCoW: false },
+  selinux: { product: 'SELinux', knownSlowCoW: false },
+
+  // macOS specific
+  defense: { product: 'Apple XProtect', knownSlowCoW: false },
+  RTProtectionDaemon: { product: 'macOS RTProtection', knownSlowCoW: false },
+  jamf: { product: 'Jamf', knownSlowCoW: false },
+};

package/extensions/pi-var/src/edr/crowdstrike.ts

@@ -0,0 +1,62 @@
+/**
+ * CrowdStrike Falcon specific detection
+ */
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import * as os from 'os';
+
+const execAsync = promisify(exec);
+
+/**
+ * Check specifically for CrowdStrike Falcon (most common CoW blocker)
+ * Uses platform-specific methods for reliable detection
+ */
+export async function detectCrowdStrike(): Promise<boolean> {
+  const platform = os.platform();
+
+  try {
+    if (platform === 'darwin') {
+      // Check for falconctl binary
+      try {
+        await execAsync('which falconctl', { timeout: 5000 });
+        return true;
+      } catch {
+        // falconctl not in PATH, check for the app
+        const { execSync } = await import('child_process');
+        try {
+          execSync('test -d /Applications/Falcon.app', { stdio: 'ignore' });
+          return true;
+        } catch {
+          // App not found
+        }
+      }
+    } else if (platform === 'linux') {
+      // Check for falcon-sensor service or binary
+      try {
+        await execAsync('which falconctl', { timeout: 5000 });
+        return true;
+      } catch {
+        // Check systemctl
+        try {
+          await execAsync('systemctl is-active falcon-sensor', { timeout: 5000 });
+          return true;
+        } catch {
+          // Service not active
+        }
+      }
+    } else if (platform === 'win32') {
+      // Check for csagent service
+      try {
+        await execAsync('sc query csagent', { timeout: 5000 });
+        return true;
+      } catch {
+        // Service not found
+      }
+    }
+  } catch {
+    // Any error means not detected
+  }
+
+  return false;
+}

package/extensions/pi-var/src/edr/detection.ts

@@ -0,0 +1,97 @@
+/**
+ * EDR detection utilities
+ */
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import * as os from 'os';
+import { EDR_PROCESSES, EDR_INFO } from './constants';
+import type { EDRDetectionResult, EDRDetails } from '../types/index';
+
+const execAsync = promisify(exec);
+
+/**
+ * Check if a specific process is running
+ */
+async function checkProcessRunning(processName: string, platform: string): Promise<boolean> {
+  try {
+    if (platform === 'darwin' || platform === 'linux') {
+      // Use pgrep for Unix-like systems
+      await execAsync(`pgrep -x "${processName}"`, { timeout: 5000 });
+      return true;
+    } else if (platform === 'win32') {
+      // Use tasklist for Windows
+      await execAsync(`tasklist /FI "IMAGENAME eq ${processName}.exe" /NH`, { timeout: 5000 });
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Detect EDR/AV software running on the system
+ * Uses multiple detection methods for robustness
+ */
+export async function detectEDR(): Promise<EDRDetectionResult> {
+  const platform = os.platform();
+  const processes = EDR_PROCESSES[platform] || [];
+  const found: string[] = [];
+  const details: EDRDetails[] = [];
+
+  for (const proc of processes) {
+    try {
+      const isRunning = await checkProcessRunning(proc, platform);
+      if (isRunning && !found.includes(proc)) {
+        found.push(proc);
+        const info = EDR_INFO[proc] || { product: proc, knownSlowCoW: false };
+        details.push({
+          process: proc,
+          product: info.product,
+          knownSlowCoW: info.knownSlowCoW,
+        });
+      }
+    } catch {
+      // Ignore errors for individual process checks
+    }
+  }
+
+  return {
+    detected: found.length > 0,
+    found,
+    details,
+  };
+}
+
+/**
+ * Check if any known CoW-slowing EDR is present
+ */
+export function hasSlowCoWEDR(result: EDRDetectionResult): boolean {
+  return result.details.some((d) => d.knownSlowCoW);
+}
+
+/**
+ * Get human-readable EDR summary for UI display
+ */
+export function getEDRSummary(result: EDRDetectionResult): string {
+  if (!result.detected) {
+    return 'No EDR/AV software detected';
+  }
+
+  const slowEdrs = result.details.filter((d) => d.knownSlowCoW);
+  const otherEdrs = result.details.filter((d) => !d.knownSlowCoW);
+
+  let summary = '';
+
+  if (slowEdrs.length > 0) {
+    summary += `CoW-impacting EDR detected: ${slowEdrs.map((d) => d.product).join(', ')}`;
+  }
+
+  if (otherEdrs.length > 0) {
+    if (summary) summary += '; ';
+    summary += `Other security software: ${otherEdrs.map((d) => d.product).join(', ')}`;
+  }
+
+  return summary;
+}

package/extensions/pi-var/src/edr/index.ts

@@ -0,0 +1,6 @@
+/**
+ * EDR (Endpoint Detection and Response) module
+ */
+
+export { detectEDR, hasSlowCoWEDR, getEDRSummary } from './detection.js';
+export { detectCrowdStrike } from './crowdstrike.js';

package/extensions/pi-var/src/environment/copy-env.ts

@@ -0,0 +1,79 @@
+/**
+ * Environment variable and file copying utilities
+ */
+
+import { promises as fs } from 'fs';
+import * as path from 'path';
+
+/**
+ * Copy a single file if it exists
+ */
+async function copySingleFile(source: string, variation: string, filename: string): Promise<void> {
+  const srcPath = path.join(source, filename);
+  const destPath = path.join(variation, filename);
+
+  try {
+    await fs.access(srcPath);
+    await fs.mkdir(path.dirname(destPath), { recursive: true });
+    await fs.copyFile(srcPath, destPath);
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code !== 'ENOENT') {
+      throw err;
+    }
+    // File doesn't exist in source, skip
+  }
+}
+
+/**
+ * Copy files matching a glob pattern
+ */
+async function copyGlobPattern(source: string, variation: string, pattern: string): Promise<void> {
+  // Simple glob implementation - split pattern and match
+  const [baseName, ...extParts] = pattern.split('*');
+  const ext = extParts.join('*');
+
+  try {
+    const entries = await fs.readdir(source, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (entry.isFile()) {
+        const name = entry.name;
+
+        // Check if file matches pattern
+        if (name.startsWith(baseName) && name.endsWith(ext)) {
+          // Additional check: ensure middle part exists for patterns like .env.*
+          if (pattern.includes('.*') && !name.slice(baseName.length, -ext.length || undefined)) {
+            continue;
+          }
+
+          await copySingleFile(source, variation, name);
+        }
+      }
+    }
+  } catch (err) {
+    // Directory doesn't exist or can't be read, skip
+    if ((err as NodeJS.ErrnoException).code !== 'ENOENT') {
+      throw err;
+    }
+  }
+}
+
+/**
+ * Copy environment files from source to variation
+ * Supports glob patterns like .env.*
+ */
+export async function copyEnvFiles(
+  source: string,
+  variation: string,
+  patterns: string[]
+): Promise<void> {
+  for (const pattern of patterns) {
+    if (pattern.includes('*')) {
+      // Handle glob patterns
+      await copyGlobPattern(source, variation, pattern);
+    } else {
+      // Handle exact file paths
+      await copySingleFile(source, variation, pattern);
+    }
+  }
+}