@praneeth_54/agentdoctor 2.0.1 → 3.0.0

package/dist/security/paths.js

@@ -49,17 +49,6 @@ export function rejectHostilePathInput(candidate) {
         }
     }
 }
-function realpathOrSelf(target) {
-    try {
-        if (fs.existsSync(target)) {
-            return fs.realpathSync(target);
-        }
-    }
-    catch {
-        // fall through
-    }
-    return target;
-}
 function realpathRoot(root) {
     try {
         return fs.realpathSync(root);
@@ -85,12 +74,51 @@ export function resolveSafeRepoPath(rootInput, candidate) {
         throw new PathEscapeError("path escapes repository root");
     }
     const realRoot = realpathRoot(root);
-    const realTarget = realpathOrSelf(absolute);
-    // Symlink / realpath escape check (both sides realpath'd when possible).
-    if (!isPathInsideRoot(realRoot, realTarget) && realTarget !== realRoot) {
+    // Existing path: realpath and verify (catches symlink escape).
+    if (fs.existsSync(absolute)) {
+        let realTarget;
+        try {
+            realTarget = fs.realpathSync(absolute);
+        }
+        catch {
+            realTarget = absolute;
+        }
+        if (!isPathInsideRoot(realRoot, realTarget) && realTarget !== realRoot) {
+            throw new PathEscapeError("path escapes repository root");
+        }
+        return realTarget;
+    }
+    // Non-existent path (create): reject if any existing ancestor realpath escapes
+    // (symlink-dir escape), then map under realRoot for /var vs /private/var.
+    let ancestor = path.dirname(absolute);
+    for (;;) {
+        if (fs.existsSync(ancestor)) {
+            let realAncestor;
+            try {
+                realAncestor = fs.realpathSync(ancestor);
+            }
+            catch {
+                realAncestor = ancestor;
+            }
+            if (!isPathInsideRoot(realRoot, realAncestor) && realAncestor !== realRoot) {
+                throw new PathEscapeError("path escapes repository root");
+            }
+            break;
+        }
+        const parent = path.dirname(ancestor);
+        if (parent === ancestor)
+            break;
+        ancestor = parent;
+    }
+    const rel = path.relative(root, absolute);
+    if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) {
+        throw new PathEscapeError("path escapes repository root");
+    }
+    const mapped = path.resolve(realRoot, rel);
+    if (!isPathInsideRoot(realRoot, mapped) && mapped !== realRoot) {
         throw new PathEscapeError("path escapes repository root");
     }
-    return realTarget;
+    return mapped;
 }
 /** Assert `candidate` resolves inside `root`; throws PathEscapeError otherwise. */
 export function assertInsideRepo(rootInput, candidate) {

package/dist/utils/fs.js

@@ -1,3 +1,4 @@
+import { randomBytes } from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
 export async function pathExists(target) {
@@ -68,8 +69,15 @@ export async function listDirectorySafe(dirPath) {
 export async function atomicWriteTextFile(filePath, content) {
     const dir = path.dirname(filePath);
     await fs.mkdir(dir, { recursive: true });
-    const tmp = path.join(dir, `.${path.basename(filePath)}.agentdoctor.${process.pid}.${Date.now()}.tmp`);
-    await fs.writeFile(tmp, content, "utf8");
+    const tmp = path.join(dir, `.${path.basename(filePath)}.${randomBytes(16).toString("hex")}.tmp`);
+    // Exclusive create + owner-only mode — closes CodeQL js/insecure-temporary-file.
+    const handle = await fs.open(tmp, "wx", 0o600);
+    try {
+        await handle.writeFile(content, "utf8");
+    }
+    finally {
+        await handle.close();
+    }
     try {
         await replaceFile(tmp, filePath);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@praneeth_54/agentdoctor",
-  "version": "2.0.1",
+  "version": "3.0.0",
   "description": "Engineering assurance for AI coding agents — repository intelligence, change evidence, safety controls, and MCP tools.",
   "type": "module",
   "bin": {