@davesheffer/hunch 1.8.2 → 1.9.2

package/dist/core/safeRepoFile.js

@@ -0,0 +1,74 @@
+import { closeSync, constants, fstatSync, lstatSync, openSync, readSync, realpathSync, } from "node:fs";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+/** Automatic repository scans are a convenience boundary, not a license to
+ * materialize arbitrarily large tracked blobs in memory. Eight MiB is well
+ * above ordinary source-file sizes while keeping one malicious/generated file
+ * from becoming an unbounded descriptor read. */
+export const MAX_REPO_SOURCE_FILE_BYTES = 8 * 1024 * 1024;
+/** Build a no-follow reader for automatic repository scanners. A Git-tracked
+ * symlink still appears in `git ls-files`; following it can copy host data into
+ * generated memory or reports. This reader accepts only one unchanged regular
+ * file beneath the canonical repository root and reads through the descriptor
+ * whose identity was checked. */
+export function createRepoFileBufferReader(root, options = {}) {
+    const lexicalRoot = resolve(root);
+    const canonicalRoot = realpathSync(lexicalRoot);
+    const maxBytes = options.maxBytes ?? MAX_REPO_SOURCE_FILE_BYTES;
+    if (!Number.isSafeInteger(maxBytes) || maxBytes < 0) {
+        throw new RangeError("maxBytes must be a non-negative safe integer");
+    }
+    return (file) => {
+        let descriptor;
+        try {
+            const target = isAbsolute(file) ? resolve(file) : resolve(lexicalRoot, file);
+            const lexicalRelative = relative(lexicalRoot, target);
+            if (!lexicalRelative || lexicalRelative === ".." || lexicalRelative.startsWith(`..${sep}`) || isAbsolute(lexicalRelative))
+                return null;
+            const before = lstatSync(target);
+            if (!before.isFile() || before.isSymbolicLink())
+                return null;
+            const canonicalTarget = realpathSync(target);
+            const canonicalRelative = relative(canonicalRoot, canonicalTarget);
+            if (!canonicalRelative || canonicalRelative === ".." || canonicalRelative.startsWith(`..${sep}`) || isAbsolute(canonicalRelative)
+                || canonicalTarget !== resolve(canonicalRoot, lexicalRelative)) {
+                return null;
+            }
+            descriptor = openSync(target, constants.O_RDONLY | constants.O_NOFOLLOW);
+            const opened = fstatSync(descriptor);
+            const after = lstatSync(target);
+            if (!opened.isFile() || !after.isFile() || after.isSymbolicLink()
+                || opened.size > maxBytes
+                || opened.dev !== before.dev || opened.ino !== before.ino
+                || after.dev !== opened.dev || after.ino !== opened.ino
+                || realpathSync(target) !== canonicalTarget) {
+                return null;
+            }
+            // Read exactly the size that passed fstat. readFileSync(fd) reads to EOF,
+            // so an in-place grow after the check could otherwise defeat the ceiling.
+            const bytes = Buffer.allocUnsafe(opened.size);
+            let offset = 0;
+            while (offset < bytes.length) {
+                const read = readSync(descriptor, bytes, offset, bytes.length - offset, offset);
+                if (read === 0)
+                    break;
+                offset += read;
+            }
+            return bytes.subarray(0, offset);
+        }
+        catch {
+            return null;
+        }
+        finally {
+            if (descriptor !== undefined)
+                closeSync(descriptor);
+        }
+    };
+}
+/** Text facade for parsers and legacy callers. Security-sensitive identities
+ * should hash the raw bytes returned by createRepoFileBufferReader first, since
+ * distinct invalid UTF-8 sequences can decode to the same replacement text. */
+export function createRepoFileReader(root, options = {}) {
+    const read = createRepoFileBufferReader(root, options);
+    return (file) => read(file)?.toString("utf8") ?? null;
+}
+//# sourceMappingURL=safeRepoFile.js.map

package/dist/extractors/comments.js

@@ -7,10 +7,11 @@
  * <!--, ;) so a matching STRING literal in code isn't mistaken for intent. (Line-based,
  * so a tagged line that is itself a string literal can still false-positive — advisory.)
  */
-import { readFileSync, readdirSync } from "node:fs";
+import { readdirSync } from "node:fs";
 import { join } from "node:path";
 import { trackedFiles } from "./git.js";
 import { toPosixTarget } from "../core/paths.js";
+import { createRepoFileReader } from "../core/safeRepoFile.js";
 const EXTS = [
     ".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs",
     ".py", ".go", ".rb", ".java", ".rs", ".php", ".cs", ".kt", ".swift", ".scala",
@@ -42,7 +43,7 @@ function sourceFiles(root) {
                 if (!SKIP.has(e.name))
                     walk(join(dir, e.name), r, depth + 1);
             }
-            else if (EXTS.some((x) => e.name.endsWith(x))) {
+            else if (e.isFile() && EXTS.some((x) => e.name.endsWith(x))) {
                 out.push(r);
             }
         }
@@ -52,14 +53,11 @@ function sourceFiles(root) {
 }
 export function extractInlineIntent(root) {
     const out = [];
+    const readSourceFile = createRepoFileReader(root);
     for (const rel of sourceFiles(root)) {
-        let content;
-        try {
-            content = readFileSync(join(root, rel), "utf8");
-        }
-        catch {
+        const content = readSourceFile(rel);
+        if (content === null)
             continue;
-        }
         if (!content.includes("hunch-"))
             continue; // cheap skip before the per-line scan
         const file = toPosixTarget(rel);