praxis-sec 1.2.0 → 1.2.1

package/cli/commands/score.js

@@ -28,7 +28,7 @@
 
 import fs from 'fs';
 import path from 'path';
-import fg from 'fast-glob';
+import fg from '../core/glob.js';
 import chalk from 'chalk';
 import ora from 'ora';
 import {

package/cli/commands/undo.js

@@ -5,8 +5,8 @@
  * Reverts changes applied by `praxis fix interactive`.
  *
  * Reads .praxis/fixes.jsonl, takes the most recent entry (or all entries
- * with --all), and reverses each edit. Per-fix git commits made by the agent
- * are preferred over manual reversal when available.
+ * with --all), and reverses the recorded edits without changing unrelated files
+ * or the Git index. Failed reversals retain their log entry for a later retry.
  *
  * USAGE:
  *   praxis undo                Revert the last applied fix
@@ -16,7 +16,8 @@
 
 import fs from 'fs';
 import path from 'path';
-import { execFileSync } from 'child_process';
+import writeFileAtomic from 'write-file-atomic';
+import { reversePlan } from '../core/fix-plan.js';
 import chalk from 'chalk';
 import * as output from '../utils/output.js';
 
@@ -32,11 +33,15 @@ export async function undoCommand(targetPath = '.', options = {}) {
     process.exit(1);
   }
 
-  const entries = fs.readFileSync(logPath, 'utf8')
-    .split('\n')
-    .filter(Boolean)
-    .map(line => { try { return JSON.parse(line); } catch { return null; } })
-    .filter(Boolean);
+  let entries;
+  try {
+    entries = fs.readFileSync(logPath, 'utf8').split('\n').filter(line => line.trim()).map(line => JSON.parse(line));
+    if (entries.some(entry => !entry || typeof entry !== 'object' || Array.isArray(entry))) throw new Error('invalid entry');
+  } catch {
+    output.error('Fix log is malformed; repair it before undoing. No files were changed.');
+    process.exitCode = 1;
+    return;
+  }
 
   if (entries.length === 0) {
     output.error('Fix log is empty.');
@@ -53,6 +58,7 @@ export async function undoCommand(targetPath = '.', options = {}) {
 
   let reverted = 0;
   let failed   = 0;
+  const undone = new Set();
 
   for (const entry of toUndo) {
     const file = entry.file || entry.finding?.file || '(unknown)';
@@ -65,22 +71,25 @@ export async function undoCommand(targetPath = '.', options = {}) {
     }
 
     try {
-      reverseEntry(root, entry);
+      reversePlan(root, entry.plan);
       console.log(chalk.green('    Reverted.'));
       reverted++;
+      undone.add(entry);
     } catch (err) {
       console.log(chalk.red(`    Failed: ${err.message}`));
       failed++;
+      // Older fixes may depend on this one. Stop so the log remains a valid stack.
+      break;
     }
   }
 
   // Truncate the log
   if (!options.dryRun && reverted > 0) {
-    const remaining = options.all ? [] : entries.slice(0, -1);
+    const remaining = entries.filter(entry => !undone.has(entry));
     if (remaining.length === 0) {
       fs.unlinkSync(logPath);
     } else {
-      fs.writeFileSync(logPath, remaining.map(e => JSON.stringify(e)).join('\n') + '\n', 'utf8');
+      writeFileAtomic.sync(logPath, remaining.map(e => JSON.stringify(e)).join('\n') + '\n', { encoding: 'utf8' });
     }
   }
 
@@ -90,72 +99,8 @@ export async function undoCommand(targetPath = '.', options = {}) {
   console.log();
 
   if (failed > 0) {
-    console.log(chalk.gray('  For failed entries, try `git checkout` or `git reset --hard` if you committed via --branch.'));
+    process.exitCode = 1;
+    console.log(chalk.gray('  Failed and unattempted fixes remain in the log. Review the changed files before retrying.'));
     console.log();
   }
 }
-
-function isGitRepo(dir) {
-  try {
-    execFileSync('git', ['-C', dir, 'rev-parse', '--is-inside-work-tree'], { stdio: 'ignore' });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function reverseEntry(root, entry) {
-  if (entry.commitHash && isGitRepo(root)) {
-    try {
-      execFileSync('git', ['-C', root, 'revert', '--no-commit', entry.commitHash], { stdio: 'ignore' });
-      return;
-    } catch {
-      console.log(chalk.yellow(`    Git revert failed for ${entry.commitHash.slice(0, 7)}. Falling back to manual text reversal.`));
-    }
-  }
-
-  const plan = entry.plan;
-  if (!plan || !Array.isArray(plan.files) || plan.files.length === 0) {
-    throw new Error('entry has no plan to reverse');
-  }
-
-  for (const fileChange of plan.files) {
-    const abs = path.resolve(root, fileChange.path);
-
-    if (fileChange.create) {
-      // We created the file — delete it
-      if (fs.existsSync(abs)) fs.unlinkSync(abs);
-      continue;
-    }
-
-    if (fileChange.append !== undefined) {
-      if (!fs.existsSync(abs)) continue;
-      const current = fs.readFileSync(abs, 'utf8');
-      // Try to remove the appended text (it may be at the end)
-      const idx = current.lastIndexOf(fileChange.append);
-      if (idx === -1) {
-        throw new Error(`appended text not found in ${fileChange.path}`);
-      }
-      const reverted = current.slice(0, idx) + current.slice(idx + fileChange.append.length);
-      fs.writeFileSync(abs, reverted, 'utf8');
-      continue;
-    }
-
-    // Standard edits — reverse find/replace
-    if (!fs.existsSync(abs)) {
-      throw new Error(`file no longer exists: ${fileChange.path}`);
-    }
-    let content = fs.readFileSync(abs, 'utf8');
-    // Reverse in opposite order in case edits are positionally dependent
-    const reversed = [...fileChange.edits].reverse();
-    for (const e of reversed) {
-      const newStr = e.replace;
-      const oldStr = e._resolvedFind || e.find;
-      if (!content.includes(newStr)) {
-        throw new Error(`reverted text not found in ${fileChange.path} (file changed since fix)`);
-      }
-      content = content.replace(newStr, oldStr);
-    }
-    fs.writeFileSync(abs, content, 'utf8');
-  }
-}

package/cli/commands/vibe-check.js

@@ -30,7 +30,7 @@ import {
   loadGitignorePatterns
 } from '../utils/patterns.js';
 import { isHighEntropyMatch, getConfidence } from '../utils/entropy.js';
-import fg from 'fast-glob';
+import fg from '../core/glob.js';
 
 // =============================================================================
 // VIBES DATA

package/cli/core/fix-plan.js

@@ -0,0 +1,274 @@
+import fs from 'fs';
+import path from 'path';
+import writeFileAtomic from 'write-file-atomic';
+import { createHash } from 'crypto';
+import { resolveProjectFile } from './fs.js';
+
+const NEVER_EDIT = [
+  /(^|\/)\.env(\.|$)/i,
+  /\.pem$|\.key$|\.p12$|\.pfx$/i,
+  /package-lock\.json$|yarn\.lock$|pnpm-lock\.yaml$/i,
+  /(^|\/)node_modules\//,
+  /(^|\/)dist\//,
+  /(^|\/)build\//,
+  /\.min\.(js|css)$/,
+];
+// Files the agent IS allowed to create or update freely (companions to fixes)
+const SAFE_NEW_FILES = [
+  /(^|\/)\.env\.example$/i,
+  /(^|\/)\.env\.sample$/i,
+  /(^|\/)\.gitignore$/i,
+];
+
+export function isProtectedFixPath(relative) {
+  const rel = relative.replace(/\\/g, '/');
+  return /(^|\/)(\.git|\.praxis|node_modules|dist|build)(\/|$)/i.test(rel) ||
+    (!SAFE_NEW_FILES.some(pattern => pattern.test(rel)) && NEVER_EDIT.some(pattern => pattern.test(rel)));
+}
+
+export function validatePlan(root, plan) {
+  try {
+    return validateFiles(root, plan);
+  } catch (err) {
+    return { ok: false, reason: err.message };
+  }
+}
+
+function validateFiles(root, plan) {
+  if (!plan || !Array.isArray(plan.files) || plan.files.length === 0) {
+    return { ok: false, reason: 'no files in plan' };
+  }
+
+  const paths = new Set();
+  for (const f of plan.files) {
+    if (!f || typeof f.path !== 'string' || !f.path) return { ok: false, reason: 'file entry missing path' };
+
+    const abs = resolveProjectFile(root, f.path);
+    const key = process.platform === 'win32' ? abs.toLowerCase() : abs;
+    if (paths.has(key)) return { ok: false, reason: `duplicate file: ${f.path}` };
+    paths.add(key);
+    const rel       = path.relative(fs.realpathSync(root), abs).replace(/\\/g, '/');
+    const isSafeNew = SAFE_NEW_FILES.some(p => p.test(rel));
+
+    // Block protected paths unless this is a known-safe companion file
+    if (isProtectedFixPath(rel)) {
+      return { ok: false, reason: `protected path: ${f.path}` };
+    }
+
+    const exists = fs.existsSync(abs);
+    if (exists && !fs.statSync(abs).isFile()) return { ok: false, reason: `not a file: ${f.path}` };
+
+    // Companion file forms (create / append)
+    if (f.create || f.append !== undefined) {
+      if (!exists && !isSafeNew) {
+        return { ok: false, reason: `cannot create new file at ${f.path}` };
+      }
+      if (f.create && typeof f.content !== 'string') {
+        return { ok: false, reason: 'create entry missing content' };
+      }
+      if (f.create && exists) return { ok: false, reason: `cannot overwrite existing file: ${f.path}` };
+      if (f.create && f.append !== undefined) return { ok: false, reason: 'create and append cannot be combined' };
+      if (f.append !== undefined && (typeof f.append !== 'string' || !f.append.trim())) {
+        return { ok: false, reason: 'append must be a string' };
+      }
+      continue;
+    }
+
+    // Standard edit form
+    if (!exists) return { ok: false, reason: `file not found: ${f.path}` };
+    if (!Array.isArray(f.edits) || f.edits.length === 0) {
+      return { ok: false, reason: `no edits for ${f.path}` };
+    }
+
+    let content = fs.readFileSync(abs, 'utf8');
+    for (const e of f.edits) {
+      if (!e || typeof e.find !== 'string' || !e.find || typeof e.replace !== 'string') {
+        return { ok: false, reason: 'edit missing find/replace' };
+      }
+      if (e.find === e.replace) {
+        return { ok: false, reason: 'edit is a no-op' };
+      }
+      const match = locateFindString(content, e.find);
+      if (match.kind === 'missing') {
+        return { ok: false, reason: `find string not present in ${f.path}` };
+      }
+      if (match.kind === 'ambiguous') {
+        return { ok: false, reason: `find string is ambiguous (${match.count} matches) in ${f.path}` };
+      }
+      // Annotate the edit with the resolved match for use during apply
+      e._resolvedFind = match.matched;
+      content = content.replace(match.matched, () => e.replace);
+    }
+  }
+  return { ok: true };
+}
+
+// Try exact match first, then whitespace-normalized match if exact misses.
+// Returns { kind: 'unique'|'ambiguous'|'missing', matched, count }
+function locateFindString(haystack, needle) {
+  const exact = countOccurrences(haystack, needle);
+  if (exact === 1) return { kind: 'unique', matched: needle, count: 1 };
+  if (exact > 1)   return { kind: 'ambiguous', matched: needle, count: exact };
+
+  // Whitespace-tolerant fallback: collapse whitespace runs and try again
+  const norm = (s) => s.replace(/[ \t]+/g, ' ').replace(/\s*\n\s*/g, '\n').trim();
+  const needleNorm = norm(needle);
+  if (!needleNorm) return { kind: 'missing', matched: null, count: 0 };
+
+  // Walk the haystack and check if any window normalizes to the same string
+  // To keep this cheap, only attempt when needle has at least one newline (likely a code block)
+  const lines = haystack.split('\n');
+  const needleLines = needleNorm.split('\n').length;
+  let foundIdx = -1;
+  let foundCount = 0;
+  for (let i = 0; i + needleLines <= lines.length; i++) {
+    const window = lines.slice(i, i + needleLines).join('\n');
+    if (norm(window) === needleNorm) {
+      foundIdx = i;
+      foundCount++;
+      if (foundCount > 1) break;
+    }
+  }
+  if (foundCount === 1) {
+    const matched = lines.slice(foundIdx, foundIdx + needleLines).join('\n');
+    return { kind: 'unique', matched, count: 1 };
+  }
+  if (foundCount > 1) return { kind: 'ambiguous', matched: null, count: foundCount };
+  return { kind: 'missing', matched: null, count: 0 };
+}
+
+function countOccurrences(haystack, needle) {
+  if (!needle) return 0;
+  let count = 0, idx = 0;
+  while ((idx = haystack.indexOf(needle, idx)) !== -1) { count++; idx += needle.length; }
+  return count;
+}
+
+function applyEdit(root, fileChange) {
+  const abs = resolveProjectFile(root, fileChange.path);
+
+  if (fileChange.create) {
+    if (fs.existsSync(abs)) throw new Error(`cannot overwrite existing file: ${fileChange.path}`);
+    fs.mkdirSync(path.dirname(abs), { recursive: true });
+    writeFileAtomic.sync(abs, fileChange.content, { encoding: 'utf8' });
+    fileChange._afterHash = hashContent(fileChange.content);
+    return;
+  }
+
+  if (fileChange.append !== undefined) {
+    fs.mkdirSync(path.dirname(abs), { recursive: true });
+    const existed = fs.existsSync(abs);
+    const existing = existed ? fs.readFileSync(abs, 'utf8') : '';
+    fileChange._createdByAppend = !existed;
+    fileChange._appendApplied = '';
+    // Avoid duplicate appends
+    if (existing.includes(fileChange.append.trim())) return;
+    const sep = existing && !existing.endsWith('\n') ? '\n' : '';
+    fileChange._appendApplied = sep + fileChange.append;
+    const updated = existing + fileChange._appendApplied;
+    writeFileAtomic.sync(abs, updated, { encoding: 'utf8' });
+    fileChange._afterHash = hashContent(updated);
+    return;
+  }
+
+  let content = fs.readFileSync(abs, 'utf8');
+  for (const e of fileChange.edits) {
+    const find = e._resolvedFind || e.find;
+    if (countOccurrences(content, find) !== 1) {
+      throw new Error(`find string drifted in ${fileChange.path} (file changed mid-plan)`);
+    }
+    e._offset = content.indexOf(find);
+    content = content.replace(find, () => e.replace);
+  }
+  writeFileAtomic.sync(abs, content, { encoding: 'utf8' });
+  fileChange._afterHash = hashContent(content);
+}
+
+const hashContent = content => createHash('sha256').update(content).digest('hex');
+
+export function snapshotPlan(root, plan) {
+  return plan.files.map(file => {
+    const abs = resolveProjectFile(root, file.path);
+    const existed = fs.existsSync(abs);
+    return { abs, existed, content: existed ? fs.readFileSync(abs) : null };
+  });
+}
+
+/** Restore every file or report exactly which restorations failed. */
+export function restoreSnapshots(snapshots) {
+  const failures = [];
+  for (const snapshot of snapshots) {
+    try {
+      if (snapshot.existed) writeFileAtomic.sync(snapshot.abs, snapshot.content);
+      else if (fs.existsSync(snapshot.abs)) fs.unlinkSync(snapshot.abs);
+    } catch (err) {
+      failures.push(`${snapshot.abs}: ${err.message}`);
+    }
+  }
+  if (failures.length) throw new Error(`restore failed: ${failures.join('; ')}`);
+}
+
+/** Validate again after approval, then roll back any partially applied plan. */
+export function applyPlan(root, plan) {
+  const validation = validatePlan(root, plan);
+  if (!validation.ok) throw new Error(validation.reason);
+  const snapshots = snapshotPlan(root, plan);
+  try {
+    for (const file of plan.files) applyEdit(root, file);
+    return snapshots;
+  } catch (err) {
+    try {
+      restoreSnapshots(snapshots);
+    } catch (restoreError) {
+      throw new Error(`${err.message}; ${restoreError.message}`);
+    }
+    throw err;
+  }
+}
+
+/** Preflight every reverse edit before touching any file; preserve later user edits. */
+export function reversePlan(root, plan) {
+  if (!plan || !Array.isArray(plan.files) || !plan.files.length) throw new Error('entry has no plan to reverse');
+  const changes = plan.files.map(file => {
+    const abs = resolveProjectFile(root, file.path);
+    if (isProtectedFixPath(path.relative(fs.realpathSync(root), abs))) throw new Error(`protected path: ${file.path}`);
+    const current = fs.readFileSync(abs, 'utf8');
+    if (file._afterHash && hashContent(current) !== file._afterHash) {
+      throw new Error(`file changed since fix: ${file.path}`);
+    }
+    if (file.create || file._createdByAppend) {
+      const expected = file.create ? file.content : file._appendApplied;
+      if (current !== expected) throw new Error(`created file changed since fix: ${file.path}`);
+      return { abs, remove: true };
+    }
+    if (file.append !== undefined) {
+      const appended = file._appendApplied ?? file.append;
+      if (!appended) return { abs, content: current };
+      if (!current.endsWith(appended)) throw new Error(`appended text no longer at end of ${file.path}`);
+      return { abs, content: current.slice(0, -appended.length) };
+    }
+    if (!Array.isArray(file.edits)) throw new Error(`no edits to reverse: ${file.path}`);
+    let content = current;
+    for (const edit of [...file.edits].reverse()) {
+      const original = edit._resolvedFind ?? edit.find;
+      if (typeof edit.replace !== 'string' || typeof original !== 'string') throw new Error('invalid reverse edit');
+      const offset = file._afterHash && Number.isInteger(edit._offset) ? edit._offset : content.indexOf(edit.replace);
+      if ((!file._afterHash && countOccurrences(content, edit.replace) !== 1) || offset < 0 ||
+          content.slice(offset, offset + edit.replace.length) !== edit.replace) {
+        throw new Error(`reverted text missing or ambiguous in ${file.path}`);
+      }
+      content = content.slice(0, offset) + original + content.slice(offset + edit.replace.length);
+    }
+    return { abs, content };
+  });
+  const snapshots = snapshotPlan(root, plan);
+  try {
+    for (const change of changes) {
+      if (change.remove) fs.unlinkSync(change.abs);
+      else writeFileAtomic.sync(change.abs, change.content, { encoding: 'utf8' });
+    }
+  } catch (err) {
+    restoreSnapshots(snapshots);
+    throw err;
+  }
+}

package/cli/core/fs.js

@@ -60,3 +60,30 @@ export function ensureDir(dir) {
   if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
   return dir;
 }
+
+/** Resolve a write target inside a project, including existing symlink parents. */
+export function resolveProjectFile(root, candidate) {
+  if (typeof candidate !== 'string' || !candidate || candidate.includes('\0')) {
+    throw new Error('file path must be a non-empty string');
+  }
+  const project = fs.realpathSync(root);
+  const inside = target => {
+    const relative = path.relative(project, target);
+    return relative && relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+  };
+  const absolute = path.resolve(project, candidate);
+  if (!inside(absolute)) throw new Error(`path escapes project: ${candidate}`);
+  let existing = absolute;
+  while (!fs.existsSync(existing)) {
+    // A dangling symlink is an existing directory entry and must not be followed.
+    try {
+      if (fs.lstatSync(existing).isSymbolicLink()) throw new Error(`dangling symlink: ${candidate}`);
+    } catch (err) {
+      if (err.code !== 'ENOENT') throw err;
+    }
+    existing = path.dirname(existing);
+  }
+  const resolved = path.join(fs.realpathSync(existing), path.relative(existing, absolute));
+  if (!inside(resolved)) throw new Error(`symlink escapes project: ${candidate}`);
+  return resolved;
+}

package/cli/core/git-clone.js

@@ -79,11 +79,11 @@ export function parseGitUrl(target = '', options = {}) {
     raw = `https://${raw}`;
   }
 
-  let provider = 'git';
-  if (/github\.com/i.test(raw)) provider = 'github';
-  else if (/gitlab\.com/i.test(raw)) provider = 'gitlab';
-  else if (/bitbucket\.org/i.test(raw)) provider = 'bitbucket';
-  else if (/dev\.azure\.com/i.test(raw)) provider = 'azure';
+  let hostname = raw.match(/^git@([^:]+):/)?.[1]?.toLowerCase() || '';
+  try { hostname = new URL(raw).hostname.toLowerCase(); } catch { /* local clone path or SCP syntax */ }
+  const provider = {
+    'github.com': 'github', 'gitlab.com': 'gitlab', 'bitbucket.org': 'bitbucket', 'dev.azure.com': 'azure',
+  }[hostname] || 'git';
 
   // Extract clean repository name
   let repoName = 'repository';
@@ -95,7 +95,9 @@ export function parseGitUrl(target = '', options = {}) {
   const displayUrl = redactGitUrl(raw);
 
   // Auth token injection for private repositories (if requested)
-  const token = options.gitToken || process.env.PRAXIS_GIT_TOKEN || process.env.GITHUB_TOKEN || process.env.GIT_TOKEN;
+  // A GitHub credential must never be forwarded to another Git host or a lookalike.
+  const token = options.gitToken || process.env.PRAXIS_GIT_TOKEN || process.env.GIT_TOKEN ||
+    (hostname === 'github.com' ? process.env.GITHUB_TOKEN : undefined);
   let cloneUrl = raw;
 
   if (token && raw.startsWith('https://')) {

package/cli/core/glob.js

@@ -0,0 +1,56 @@
+/**
+ * Scanner file discovery boundary. Target-controlled patterns are bounded before
+ * fast-glob/braces parse them (GHSA-vfj7-8cjw-p6xm has no upstream patch yet).
+ * Directory symlinks must not turn a project scan into a scan of the host.
+ */
+import fastGlob from 'fast-glob';
+
+const MAX_PATTERNS = 4096;
+const MAX_LENGTH = 8192;
+const MAX_DEPTH = 16;
+const MAX_EXPANSIONS = 1024;
+
+export function validateGlobPatterns(patterns) {
+  const list = Array.isArray(patterns) ? patterns : [patterns];
+  if (list.length > MAX_PATTERNS) throw new Error('Too many glob patterns');
+  for (const pattern of list) {
+    if (typeof pattern !== 'string' || pattern.length > MAX_LENGTH) throw new Error('Invalid or oversized glob pattern');
+    const stack = [];
+    let expansions = 1;
+    for (let i = 0; i < pattern.length; i++) {
+      const char = pattern[i];
+      if (char === '\\') { i++; continue; }
+      if (char === '{') {
+        stack.push({ start: i, alternatives: 1 });
+        if (stack.length > MAX_DEPTH) throw new Error('Glob brace nesting exceeds safe limit');
+      } else if (char === ',' && stack.length) {
+        stack[stack.length - 1].alternatives++;
+      } else if (char === '}' && stack.length) {
+        const group = stack.pop();
+        const range = pattern.slice(group.start + 1, i).match(/^(-?\d+|[a-zA-Z])\.\.(-?\d+|[a-zA-Z])(?:\.\.(-?\d+))?$/);
+        let alternatives = group.alternatives;
+        if (range) {
+          const number = value => /^-?\d+$/.test(value) ? Number(value) : value.charCodeAt(0);
+          const step = Math.abs(Number(range[3] || 1));
+          alternatives = Math.floor(Math.abs(number(range[2]) - number(range[1])) / step) + 1;
+        }
+        expansions *= alternatives;
+        if (!Number.isFinite(expansions) || expansions > MAX_EXPANSIONS) throw new Error('Glob brace expansion exceeds safe limit');
+      }
+    }
+  }
+}
+
+function safeOptions(patterns, options) {
+  validateGlobPatterns(patterns);
+  if (options.ignore) validateGlobPatterns(options.ignore);
+  return { ...options, followSymbolicLinks: false };
+}
+
+function glob(patterns, options = {}) {
+  return fastGlob(patterns, safeOptions(patterns, options));
+}
+
+glob.sync = (patterns, options = {}) => fastGlob.sync(patterns, safeOptions(patterns, options));
+
+export default glob;