codegate-ai 0.14.1 → 0.14.2

package/dist/pipeline.js

@@ -202,9 +202,6 @@ function layer3ErrorFinding(resourceId, status, description) {
         suppressed: false,
     });
 }
-function isRegistryMetadataResource(resourceId) {
-    return (resourceId.startsWith("npm:") || resourceId.startsWith("pypi:") || resourceId.startsWith("git:"));
-}
 export function layer3OutcomesToFindings(outcomes, options = {}) {
     const findings = [];
     for (const outcome of outcomes) {
@@ -219,11 +216,17 @@ export function layer3OutcomesToFindings(outcomes, options = {}) {
         const parsed = parseLayer3Response(outcome.resourceId, outcome.result.metadata);
         const derived = deriveLayer3ToolFindings(outcome.resourceId, outcome.result.metadata, options);
         const combined = [...parsed, ...derived];
+        // If a Layer 3 resource was fetched successfully but carries no
+        // actionable metadata (no `findings[]`, no `tools[]`), that is not an
+        // issue with the scan target itself — it usually means the default
+        // no-outbound-call resource executor recorded only a URL stub, or that
+        // a host-configured MCP endpoint simply returned an unrecognised
+        // payload. Previously we emitted a LOW `layer3-network_error`
+        // "schema mismatch" finding whose `file_path` was the remote URL,
+        // which leaked host-level noise into every per-target scan report.
+        // Fetch-level anomalies that are unrelated to the scan target are now
+        // dropped silently for all resource kinds.
         if (combined.length === 0) {
-            if (isRegistryMetadataResource(outcome.resourceId)) {
-                continue;
-            }
-            findings.push(layer3ErrorFinding(outcome.resourceId, "network_error", "Deep scan response schema mismatch: expected metadata.findings[] or metadata.tools[]"));
             continue;
         }
         findings.push(...combined);

package/dist/scan.js

@@ -121,6 +121,47 @@ function isRegularFile(path) {
         return false;
     }
 }
+/** True when `candidatePath` resolves at or below `root`. */
+function isPathInside(root, candidatePath) {
+    const resolvedCandidate = resolve(candidatePath);
+    const resolvedRoot = resolve(root);
+    if (resolvedCandidate === resolvedRoot) {
+        return true;
+    }
+    const rel = relative(resolvedRoot, resolvedCandidate);
+    if (rel === "" || rel === ".") {
+        return true;
+    }
+    if (rel.startsWith("..")) {
+        return false;
+    }
+    // On Windows, relative() may return an absolute path across drives.
+    if (rel.includes(":")) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Decide whether a user-scope candidate at `candidatePath` should be attached
+ * to a scan of `scanTarget` rooted at `homeDir`.
+ *
+ * User-scope patterns (e.g. `~/.agents/skills/*/SKILL.md`) walk the whole
+ * home directory, so they can match files belonging to completely unrelated
+ * skills or agents. When the scan target is itself a specific location
+ * **inside** the user's home — e.g. scanning a single skill directory — any
+ * user-scope match outside that scan target belongs to a different scan and
+ * must not be attributed here.
+ *
+ * When the scan target lives outside the home directory (for example a
+ * project root in a workspace), user-scope matches are accepted as legitimate
+ * host-wide context for that scan.
+ */
+function shouldKeepUserScopeCandidate(scanTarget, homeDir, candidatePath) {
+    if (isPathInside(homeDir, scanTarget)) {
+        return isPathInside(scanTarget, candidatePath);
+    }
+    return true;
+}
 function toUserReportPath(pattern) {
     const normalized = normalizeUserScopePattern(pattern);
     return `~/${normalized}`;
@@ -261,6 +302,14 @@ function collectSelectedCandidates(absoluteTarget, walkedFiles, patterns, option
             const userPattern = normalizeUserScopePattern(candidate.pattern);
             if (userPattern.includes("*")) {
                 for (const match of collectUserScopeWildcardMatches(options.homeDir, userPattern)) {
+                    // A scan whose target itself lives under the user's home directory
+                    // (e.g. a single skill at `~/.codex/skills/foo`) must only report
+                    // findings about files inside that target. User-scope wildcards
+                    // walk the whole home tree, so they can match sibling skills or
+                    // other agents that belong to different scans; drop those here.
+                    if (!shouldKeepUserScopeCandidate(absoluteTarget, options.homeDir, match.absolutePath)) {
+                        continue;
+                    }
                     const reportPath = toUserReportPath(match.relativePath);
                     if (!matchesCollectionKinds(reportPath, options.collectKinds)) {
                         continue;
@@ -280,6 +329,9 @@ function collectSelectedCandidates(absoluteTarget, walkedFiles, patterns, option
             if (!existsSync(absolutePath) || !isRegularFile(absolutePath)) {
                 continue;
             }
+            if (!shouldKeepUserScopeCandidate(absoluteTarget, options.homeDir, absolutePath)) {
+                continue;
+            }
             const reportPath = toUserReportPath(userPattern);
             if (!matchesCollectionKinds(reportPath, options.collectKinds)) {
                 continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codegate-ai",
-  "version": "0.14.1",
+  "version": "0.14.2",
   "description": "Pre-flight security scanner for AI coding tool configurations.",
   "license": "MIT",
   "type": "module",