gemstack-ai 1.4.0 → 2.0.0

package/src/commands/hooks.js

@@ -2,10 +2,58 @@ const fs = require('fs');
 const path = require('path');
 const logger = require('../lib/logger');
 
-const PRE_COMMIT_HOOK = `#!/bin/sh
-# Gemstack - Git Pre-commit Hook
-# Este hook previene que subas secretos o rompas la Ley de Seguridad (Rule 03).
+const SECRET_PATTERNS = [
+    { type: 'GOOGLE_AI_KEY', regex: new RegExp('AIza[0-9A-Za-z_-]{35}'), description: 'Google AI / Gemini API Key' },
+    { type: 'OPENAI_KEY', regex: new RegExp('sk-(?:proj-)?[a-zA-Z0-9_-]{20,}'), description: 'OpenAI API Key' },
+    { type: 'ANTHROPIC_KEY', regex: new RegExp('sk-ant-[a-zA-Z0-9_-]{20,}'), description: 'Anthropic API Key' },
+    { type: 'GITHUB_PAT', regex: new RegExp('(?:' + 'ghp_' + '[0-9a-zA-Z]{36}|' + 'github_pat_' + '[0-9a-zA-Z_]{22,})'), description: 'GitHub Personal Access Token' },
+    { type: 'SLACK_TOKEN', regex: new RegExp('xox' + '[baprs]-[0-9a-zA-Z-]{10,}'), description: 'Slack Token' },
+    { type: 'STRIPE_KEY', regex: new RegExp('sk_' + '(?:live|test)_[0-9a-zA-Z]{24}'), description: 'Stripe Secret Key' },
+    { type: 'AWS_KEY', regex: new RegExp('AK' + 'IA[0-9A-Z]{16}'), description: 'AWS Access Key' },
+    { type: 'PRIVATE_KEY', regex: /-----BEGIN [A-Z ]*PRIVATE KEY-----/, description: 'Private Cryptographic Key' }
+];
 
+function detectSecrets(content) {
+    if (!content || typeof content !== 'string') return [];
+    const results = [];
+    const lines = content.split('\n');
+
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.includes('gemstack:allow-secret') || line.includes('NOOP_TEST_FIXTURE')) {
+            continue;
+        }
+        for (const pattern of SECRET_PATTERNS) {
+            const match = line.match(pattern.regex);
+            if (match) {
+                results.push({
+                    type: pattern.type,
+                    description: pattern.description,
+                    match: match[0],
+                    lineNumber: i + 1,
+                    lineSnippet: line.trim()
+                });
+            }
+        }
+    }
+    return results;
+}
+
+const BASH_PATTERNS = [
+    'AIza[0-9A-Za-z_-]{35}',
+    'sk-(proj-)?[a-zA-Z0-9_-]{20,}',
+    'sk-ant-',
+    'gh' + 'p_',
+    'github_' + 'pat_',
+    'xox' + '[baprs]-',
+    'sk_' + 'live_',
+    'sk_' + 'test_',
+    'AK' + 'IA[0-9A-Z]{16}',
+    '-----BEGIN [A-Z ]*PRIVATE KEY-----'
+].join('|');
+
+const GEMSTACK_SECURITY_BLOCK = `
+# --- [Gemstack] Active Security Scanner ---
 echo "[Gemstack] Ejecutando análisis de seguridad local..."
 
 # 1. Evitar que se suban archivos .env
@@ -17,10 +65,8 @@ fi
 
 # 2. Buscar marcadores de conflicto de merge olvidados
 if git diff --cached -S"<<<<<<< HEAD" --quiet; then
-    # -quiet retorna 0 si encuentra coincidencias (no output)
     :
 else
-    # Si git diff encuenta "<<<<<<<"
     if git diff --cached | grep -E "^\\+<<<<<<<" > /dev/null; then
         echo "❌ ERROR (Gemstack): Hay marcadores de conflicto de git (<<<<<<<) en tus archivos."
         echo "Resuélvelos antes de hacer commit."
@@ -28,19 +74,35 @@ else
     fi
 fi
 
-# 3. Buscar posibles llaves expuestas (Stripe, AWS, JWT genéricos) en código agregado
-# Extrae las líneas añadidas y busca patrones peligrosos
-if git diff --cached | grep -E "^\\+.*(sk_live_|sk_test_|AKIA[0-9A-Z]{16}|xoxb-|ghp_)" > /dev/null; then
-    echo "❌ ERROR (Gemstack/CSO): ¡Posible llave secreta detectada en el código!"
+# 3. Buscar llaves y credenciales expuestas en código agregado (excluyendo tests y specs)
+if git diff --cached -- . ':!tests' ':!specs' | grep -E "^\\+.*(${BASH_PATTERNS})" > /dev/null; then
+    echo "❌ ERROR (Gemstack/CSO): ¡Posible llave secreta detectada en el código agregado!"
     echo "Regla 03: Cero Exposición de Credenciales. Extrae el secreto a una variable de entorno."
     exit 1
 fi
 
 echo "✅ [Gemstack] Código limpio. Committing..."
-exit 0
+# --- End [Gemstack] ---
 `;
 
-function installHooks(targetDir) {
+function generateChainedHook(hasWrappedHook) {
+    let script = '#!/bin/sh\n';
+    if (hasWrappedHook) {
+        script += `# Gemstack Hook Dispatcher with Preserved User Hook\n\n`;
+        script += `WRAPPED_HOOK="$(dirname "$0")/pre-commit.gemstack-wrapped"\n`;
+        script += `if [ -f "$WRAPPED_HOOK" ]; then\n`;
+        script += `    if ! "$WRAPPED_HOOK"; then\n`;
+        script += `        echo "❌ ERROR: El pre-commit hook previo del usuario falló."\n`;
+        script += `        exit 1\n`;
+        script += `    fi\n`;
+        script += `fi\n\n`;
+    }
+    script += GEMSTACK_SECURITY_BLOCK;
+    script += '\nexit 0\n';
+    return script;
+}
+
+function installHooks(targetDir = process.cwd()) {
     const gitDir = path.join(targetDir, '.git');
     const hooksDir = path.join(gitDir, 'hooks');
     const preCommitPath = path.join(hooksDir, 'pre-commit');
@@ -55,8 +117,21 @@ function installHooks(targetDir) {
             fs.mkdirSync(hooksDir, { recursive: true });
         }
 
-        fs.writeFileSync(preCommitPath, PRE_COMMIT_HOOK, { mode: 0o755 });
-        logger.ok('Git hooks (pre-commit) instalados exitosamente.');
+        let hasWrappedHook = false;
+        if (fs.existsSync(preCommitPath)) {
+            const existingContent = fs.readFileSync(preCommitPath, 'utf8');
+            if (!existingContent.includes('[Gemstack]')) {
+                // Preserve user hook by renaming to wrapped script
+                const wrappedPath = path.join(hooksDir, 'pre-commit.gemstack-wrapped');
+                fs.writeFileSync(wrappedPath, existingContent, { mode: 0o755 });
+                hasWrappedHook = true;
+                logger.info('Pre-commit hook previo detectado: preservado como pre-commit.gemstack-wrapped.');
+            }
+        }
+
+        const newHookContent = generateChainedHook(hasWrappedHook);
+        fs.writeFileSync(preCommitPath, newHookContent, { mode: 0o755 });
+        logger.ok('Git hooks (pre-commit) instalados exitosamente con encadenamiento seguro.');
         return true;
     } catch (err) {
         logger.error(`Error instalando git hooks: ${err.message}`);
@@ -64,4 +139,13 @@ function installHooks(targetDir) {
     }
 }
 
-module.exports = { installHooks };
+async function hooksCommand(flags = {}) {
+    const targetDir = typeof flags === 'string' ? flags : (flags.target || process.cwd());
+    return installHooks(targetDir);
+}
+
+hooksCommand.installHooks = installHooks;
+hooksCommand.detectSecrets = detectSecrets;
+hooksCommand.SECRET_PATTERNS = SECRET_PATTERNS;
+
+module.exports = hooksCommand;

package/src/commands/init.js

@@ -31,7 +31,7 @@ module.exports = async (flags) => {
 
     walkDir(templateDir, (filePath) => {
         const relativePath = path.relative(templateDir, filePath).replace(/\\/g, '/');
-        const destPath = fssafe.resolveSafe(targetDir, relativePath);
+        const destPath = fssafe.resolveSafeStrict(targetDir, relativePath);
 
         if (fs.existsSync(destPath)) {
             if (['handoff.md', 'handoff_archive.md', '.gemstack/learnings.md', '.gemstack/state.json'].includes(relativePath)) {

package/src/commands/install.js

@@ -1,72 +1,197 @@
 const fs = require('fs');
 const path = require('path');
-const https = require('https');
+const crypto = require('crypto');
 const fssafe = require('../lib/filesystem-safe');
 const logger = require('../lib/logger');
 const manifestLib = require('../lib/manifest');
 
-async function fetchUrl(url) {
-    const response = await fetch(url);
-    if (!response.ok) {
-        throw new Error(`Failed to fetch: ${response.status} ${response.statusText}`);
+const MAX_SKILL_PAYLOAD_BYTES = 262144; // 256 KB
+const FETCH_TIMEOUT_MS = 8000;
+const SKILL_SLUG_REGEX = /^[a-z0-9][a-z0-9-_]{1,63}$/;
+
+function validateSkillPayloadSize(sizeBytes) {
+    if (sizeBytes > MAX_SKILL_PAYLOAD_BYTES) {
+        const err = new Error(`Skill payload too large: ${sizeBytes} bytes exceeds maximum limit of ${MAX_SKILL_PAYLOAD_BYTES} bytes`);
+        err.code = 'SKILL_PAYLOAD_TOO_LARGE';
+        throw err;
     }
-    return await response.text();
+    return true;
 }
 
-function extractSkillName(content) {
-    const match = content.match(/^name:\s*(.+)$/m);
-    return match ? match[1].trim() : null;
+function validateSkillSlug(slug) {
+    if (!slug || typeof slug !== 'string' || !SKILL_SLUG_REGEX.test(slug)) {
+        const err = new Error(`Invalid skill slug "${slug}". Must match ${SKILL_SLUG_REGEX}`);
+        err.code = 'INVALID_SKILL_SLUG';
+        throw err;
+    }
+    return true;
 }
 
-module.exports = async (url, flags) => {
-    if (!url) {
-        logger.error("Debe proporcionar una URL. Ejemplo: gemstack install https://raw.githubusercontent.com/.../SKILL.md");
-        process.exit(1);
+function isPrivateOrLoopbackHost(hostname) {
+    const lower = (hostname || '').toLowerCase().trim();
+    if (lower === 'localhost' || lower === '::1' || lower === '127.0.0.1') {
+        return true;
+    }
+    const ipv4Match = lower.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+    if (ipv4Match) {
+        const o1 = Number(ipv4Match[1]);
+        const o2 = Number(ipv4Match[2]);
+        if (o1 === 10) return true;
+        if (o1 === 127) return true;
+        if (o1 === 169 && o2 === 254) return true;
+        if (o1 === 172 && (o2 >= 16 && o2 <= 31)) return true;
+        if (o1 === 192 && o2 === 168) return true;
     }
+    return false;
+}
 
-    const targetDir = flags.target || process.cwd();
-    logger.info(`Descargando skill desde: ${url}`);
+function validateUrlSafety(urlStr, flags = {}) {
+    let parsed;
+    try {
+        parsed = new URL(urlStr);
+    } catch (e) {
+        const err = new Error(`Malformed URL: ${urlStr}`);
+        err.code = 'MALFORMED_URL';
+        throw err;
+    }
+
+    if (parsed.protocol !== 'https:' && !flags.allowInsecureHttp) {
+        const err = new Error(`Insecure HTTP protocol blocked. HTTPS is required: ${urlStr}`);
+        err.code = 'INSECURE_HTTP_BLOCKED';
+        throw err;
+    }
+
+    if (isPrivateOrLoopbackHost(parsed.hostname)) {
+        const err = new Error(`Access to private or loopback IP address blocked: ${parsed.hostname}`);
+        err.code = 'PRIVATE_IP_BLOCKED';
+        throw err;
+    }
+
+    return parsed;
+}
+
+async function fetchSkillUrl(url, flags = {}) {
+    validateUrlSafety(url, flags);
+
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
 
     try {
-        const content = await fetchUrl(url);
-        
-        // Ensure it's a valid skill file
-        if (!content.includes('---')) {
-            throw new Error('El archivo descargado no parece un SKILL válido (no tiene frontmatter).');
+        const response = await fetch(url, { signal: controller.signal, redirect: 'error' });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch: ${response.status} ${response.statusText}`);
         }
 
-        const skillName = extractSkillName(content);
-        if (!skillName) {
-            throw new Error('No se encontró "name: <nombre>" en el frontmatter del SKILL.');
+        const contentLength = response.headers.get('content-length');
+        if (contentLength) {
+            validateSkillPayloadSize(Number(contentLength));
         }
 
-        // Calculate path
-        const relativePath = `.agents/skills/${skillName}/SKILL.md`;
-        const destPath = fssafe.resolveSafe(targetDir, relativePath);
+        const buffer = await response.arrayBuffer();
+        validateSkillPayloadSize(buffer.byteLength);
 
-        if (flags.dryRun) {
-            logger.ok(`Dry run: Se instalaría el skill "${skillName}" en ${relativePath}`);
-            return;
+        return Buffer.from(buffer).toString('utf8');
+    } catch (e) {
+        if (e.name === 'AbortError') {
+            const err = new Error(`Download timed out after ${FETCH_TIMEOUT_MS}ms`);
+            err.code = 'FETCH_TIMEOUT';
+            throw err;
         }
+        throw e;
+    } finally {
+        clearTimeout(timer);
+    }
+}
 
-        // Install the skill
-        fssafe.ensureDir(path.dirname(destPath));
-        fs.writeFileSync(destPath, content, 'utf8');
-
-        // Update manifest
-        const manifest = manifestLib.loadManifest(targetDir);
-        if (!manifest.files) manifest.files = [];
-        
-        const checksum = manifestLib.getChecksum(Buffer.from(content, 'utf8'));
-        const ex = manifest.files.find(f => f.path === relativePath);
-        if (ex) ex.checksum = checksum;
-        else manifest.files.push({ path: relativePath, checksum });
-        
-        manifestLib.saveManifest(targetDir, manifest, false);
-
-        logger.ok(`✅ Skill "${skillName}" instalado exitosamente en ${relativePath}`);
-    } catch (e) {
-        logger.error(`Error instalando el skill: ${e.message}`);
-        process.exit(1);
+function inspectSkillContent(content) {
+    if (!content || typeof content !== 'string') {
+        const err = new Error('Skill content is empty or invalid');
+        err.code = 'INVALID_SKILL_FRONTMATTER';
+        throw err;
     }
-};
+
+    const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!frontmatterMatch) {
+        const err = new Error('El archivo descargado no parece un SKILL válido (no tiene frontmatter delimitado por ---).');
+        err.code = 'INVALID_SKILL_FRONTMATTER';
+        throw err;
+    }
+
+    const frontmatterBody = frontmatterMatch[1];
+    const nameMatch = frontmatterBody.match(/^name:\s*(.+)$/m);
+    if (!nameMatch || !nameMatch[1].trim()) {
+        const err = new Error('No se encontró "name: <nombre>" en el frontmatter del SKILL.');
+        err.code = 'INVALID_SKILL_FRONTMATTER';
+        throw err;
+    }
+
+    const rawName = nameMatch[1].trim();
+    validateSkillSlug(rawName);
+
+    const sha256 = crypto.createHash('sha256').update(content, 'utf8').digest('hex');
+
+    return {
+        name: rawName,
+        sha256,
+        content
+    };
+}
+
+async function install(arg1, arg2) {
+    let url;
+    let flags = {};
+
+    if (typeof arg1 === 'string') {
+        url = arg1;
+        flags = arg2 || {};
+    } else if (arg1 && typeof arg1 === 'object') {
+        flags = arg1;
+        url = flags.url;
+    } else {
+        flags = arg2 || {};
+    }
+
+    if (!url) {
+        const err = new Error("Debe proporcionar una URL. Ejemplo: gemstack install https://raw.githubusercontent.com/.../SKILL.md");
+        err.code = 'MISSING_URL';
+        throw err;
+    }
+
+    const targetDir = flags.target || process.cwd();
+    logger.info(`Descargando skill desde: ${url}`);
+
+    const rawContent = await fetchSkillUrl(url, flags);
+    const inspected = inspectSkillContent(rawContent);
+
+    const relativePath = `.agents/skills/${inspected.name}/SKILL.md`;
+
+    if (flags.dryRun) {
+        logger.ok(`Dry run: Se instalaría el skill "${inspected.name}" (SHA-256: ${inspected.sha256.slice(0, 16)}...) en ${relativePath}`);
+        return { name: inspected.name, path: relativePath, sha256: inspected.sha256, installed: false };
+    }
+
+    // Atomic write inside project boundaries
+    fssafe.withConfinedAtomicWrite(targetDir, relativePath, (tempFile) => {
+        fs.writeFileSync(tempFile, rawContent, 'utf8');
+    });
+
+    // Update manifest
+    const manifest = manifestLib.loadManifest(targetDir);
+    if (!manifest.files) manifest.files = [];
+    
+    const ex = manifest.files.find(f => f.path === relativePath);
+    if (ex) ex.checksum = inspected.sha256;
+    else manifest.files.push({ path: relativePath, checksum: inspected.sha256 });
+    
+    manifestLib.saveManifest(targetDir, manifest, false);
+
+    logger.ok(`✅ Skill "${inspected.name}" instalado exitosamente en ${relativePath} (SHA-256: ${inspected.sha256.slice(0, 12)}...)`);
+    return { name: inspected.name, path: relativePath, sha256: inspected.sha256, installed: true };
+}
+
+install.validateSkillPayloadSize = validateSkillPayloadSize;
+install.validateSkillSlug = validateSkillSlug;
+install.validateUrlSafety = validateUrlSafety;
+install.inspectSkillContent = inspectSkillContent;
+
+module.exports = install;

package/src/commands/spec.js

@@ -0,0 +1,105 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const logger = require('../lib/logger');
+const fssafe = require('../lib/filesystem-safe');
+const { loadState } = require('../lib/state');
+const { detectSpecConflicts, mergeSpecs } = require('../lib/spec-merge');
+const { detectRigorLevel, validateRigorRequirements } = require('../lib/sdd-rigor');
+const { validateContractAmendments } = require('../lib/contract-amendments');
+
+async function specCommand(args = [], flags = {}) {
+  const targetDir = flags.target ? path.resolve(flags.target) : process.cwd();
+  const subCommand = args[0] || 'validate';
+
+  const state = loadState(targetDir);
+  if (!state || !state.active_spec) {
+    logger.error('No hay una especificación activa configurada en .gemstack/state.json');
+    process.exit(1);
+  }
+
+  const activeSpecDir = fssafe.resolveSafe(targetDir, state.active_spec);
+  const activeSpecFile = path.join(activeSpecDir, 'spec.md');
+
+  if (!fs.existsSync(activeSpecFile)) {
+    logger.error(`spec.md no encontrado en ${activeSpecFile}`);
+    process.exit(1);
+  }
+
+  const activeSpecContent = fs.readFileSync(activeSpecFile, 'utf8');
+
+  switch (subCommand) {
+    case 'merge': {
+      const targetSpecPath = args[1];
+      if (!targetSpecPath) {
+        logger.error('Uso: gemstack spec merge <ruta-o-rama-de-spec>');
+        process.exit(1);
+      }
+
+      const incomingDir = fssafe.resolveSafe(targetDir, targetSpecPath);
+      const incomingSpecFile = path.join(incomingDir, 'spec.md');
+
+      if (!fs.existsSync(incomingSpecFile)) {
+        logger.error(`spec.md entrante no encontrado en: ${incomingSpecFile}`);
+        process.exit(1);
+      }
+
+      const incomingContent = fs.readFileSync(incomingSpecFile, 'utf8');
+      logger.info(`Comparando especificaciones: "${state.active_spec}" vs "${targetSpecPath}"...`);
+
+      const conflictReport = detectSpecConflicts(activeSpecContent, incomingContent);
+      if (!conflictReport.valid) {
+        logger.error(`[SPEC_MERGE_CONFLICT] Se detectaron ${conflictReport.conflicts.length} conflicto(s):`);
+        for (const c of conflictReport.conflicts) {
+          logger.error(`  - [${c.type}] ${c.id}: ${c.reason}`);
+        }
+        process.exit(1);
+      }
+
+      logger.ok('No se detectaron colisiones de contratos ni duplicados de tests canónicos.');
+      const merged = mergeSpecs(activeSpecContent, incomingContent);
+      logger.ok(`Fusión completada con éxito (${merged.contracts.length} contratos, ${merged.tests.length} tests canónicos).`);
+      break;
+    }
+
+    case 'validate': {
+      const rigor = detectRigorLevel(activeSpecContent);
+      logger.info(`Validando especificación "${state.active_spec}" (Rigor: ${rigor})...`);
+
+      const planFile = path.join(activeSpecDir, 'plan.md');
+      const tasksFile = path.join(activeSpecDir, 'tasks.md');
+      const planContent = fs.existsSync(planFile) ? fs.readFileSync(planFile, 'utf8') : null;
+      const tasksContent = fs.existsSync(tasksFile) ? fs.readFileSync(tasksFile, 'utf8') : null;
+
+      const { extractTestMatrixBlock } = require('../lib/test-matrix');
+      const matrixResult = extractTestMatrixBlock(activeSpecContent);
+      const testMatrix = !matrixResult.isLegacy ? matrixResult.matrix : [];
+
+      const { readSidecar } = require('../lib/state');
+      const sidecar = readSidecar(activeSpecDir);
+
+      const rigorResult = validateRigorRequirements(rigor, {
+        specContent: activeSpecContent,
+        planContent,
+        tasksContent,
+        testMatrix,
+        sidecar
+      });
+
+      if (!rigorResult.valid) {
+        logger.error(`[RIGOR_VALIDATION_FAILED] ${rigorResult.code}: ${rigorResult.error}`);
+        process.exit(1);
+      }
+
+      logger.ok(`Especificación válida bajo rigor "${rigor}".`);
+      break;
+    }
+
+    default:
+      logger.error(`Subcomando desconocido para "gemstack spec": ${subCommand}. Subcomandos disponibles: validate, merge`);
+      process.exit(1);
+  }
+}
+
+module.exports = specCommand;

package/src/commands/update.js

@@ -24,7 +24,7 @@ module.exports = async (flags) => {
 
     walkDir(templateDir, (filePath) => {
         const relativePath = path.relative(templateDir, filePath).replace(/\\/g, '/');
-        const destPath = fssafe.resolveSafe(targetDir, relativePath);
+        const destPath = fssafe.resolveSafeStrict(targetDir, relativePath);
         
         const tmplContent = fs.readFileSync(filePath);
         const tmplCheck = manifestLib.getChecksum(tmplContent);

package/src/commands/verify.js

@@ -87,6 +87,16 @@ module.exports = async (flags) => {
         } else {
             logger.ok('Sección inmutable "4. Intentos fallidos" preservada.');
         }
+
+        // Cross-Audit con Git Log (Gemstack 2.0 Sprint D)
+        const { crossAuditMemoryWithGit } = require('../lib/memory-audit');
+        const memAudit = crossAuditMemoryWithGit(targetDir);
+        if (!memAudit.valid && memAudit.unrecorded_commits.length > 0) {
+            logger.warn(`Detectados commits recientes no registrados en handoff.md: ${memAudit.unrecorded_commits.map(c => c.hash).join(', ')}`);
+            totalWarnings++;
+        } else {
+            logger.ok('Memoria cruzada (handoff.md <-> git log) verificada.');
+        }
     }
 
     // 3. Consistencia de Estado Local (.gemstack/state.json)

package/src/lib/backup.js

@@ -5,12 +5,12 @@ const logger = require('./logger');
 
 module.exports = {
     backupFile: (targetDir, relativeFilePath, dryRun, sessionTimestamp) => {
-        const fullPath = fssafe.resolveSafe(targetDir, relativeFilePath);
+        const fullPath = fssafe.resolveSafeStrict(targetDir, relativeFilePath);
         if (!fs.existsSync(fullPath)) return;
 
         const timestamp = sessionTimestamp || new Date().toISOString().replace(/[:.]/g, '-');
-        const backupDir = fssafe.resolveSafe(targetDir, `.gemstack/backups/${timestamp}`);
-        const backupDest = fssafe.resolveSafe(backupDir, relativeFilePath);
+        const backupDir = fssafe.resolveSafeStrict(targetDir, `.gemstack/backups/${timestamp}`);
+        const backupDest = fssafe.resolveSafeStrict(backupDir, relativeFilePath);
 
         logger.info(`Backup: ${relativeFilePath}`);
         if (!dryRun) {