codegate-ai 0.14.0 → 0.14.2

package/dist/config.d.ts

@@ -56,6 +56,22 @@ export interface CodeGateConfig {
     workflow_audits?: WorkflowAuditConfig;
     suppress_findings: string[];
     suppression_rules?: SuppressionRule[];
+    /**
+     * Timeout (in milliseconds) applied to Layer 3 remote resource fetches
+     * (npm/PyPI registry lookups, git ls-remote, and any http/sse MCP probes).
+     * Kept deliberately low so a slow or deliberately stalling host cannot
+     * hang a scan. Overridable via `CODEGATE_LAYER3_REMOTE_FETCH_TIMEOUT_MS`.
+     */
+    layer3_remote_fetch_timeout_ms: number;
+    /**
+     * Maximum response size (in bytes) accepted from a Layer 3 remote fetch.
+     * A declared `Content-Length` above this value is rejected immediately,
+     * and the streaming reader aborts once the running byte count exceeds
+     * this limit (defends against servers that lie about or omit
+     * `Content-Length`). Overridable via
+     * `CODEGATE_LAYER3_REMOTE_FETCH_MAX_BYTES`.
+     */
+    layer3_remote_fetch_max_bytes: number;
 }
 export interface CliConfigOverrides {
     format?: OutputFormat;
@@ -68,6 +84,10 @@ export interface ResolveConfigOptions {
     cli?: CliConfigOverrides;
 }
 export declare const DEFAULT_CONFIG: CodeGateConfig;
+/** Env var name that overrides `layer3_remote_fetch_timeout_ms`. */
+export declare const LAYER3_REMOTE_FETCH_TIMEOUT_ENV = "CODEGATE_LAYER3_REMOTE_FETCH_TIMEOUT_MS";
+/** Env var name that overrides `layer3_remote_fetch_max_bytes`. */
+export declare const LAYER3_REMOTE_FETCH_MAX_BYTES_ENV = "CODEGATE_LAYER3_REMOTE_FETCH_MAX_BYTES";
 export declare function resolveEffectiveConfig(options: ResolveConfigOptions): CodeGateConfig;
 export declare function computeExitCode(findings: Finding[], threshold: SeverityThreshold): number;
 export declare function applyConfigPolicy(report: CodeGateReport, config: CodeGateConfig): CodeGateReport;

package/dist/config.js

@@ -49,7 +49,32 @@ export const DEFAULT_CONFIG = {
     workflow_audits: { enabled: false },
     suppress_findings: [],
     suppression_rules: [],
+    layer3_remote_fetch_timeout_ms: 5000,
+    layer3_remote_fetch_max_bytes: 1_048_576,
 };
+/** Env var name that overrides `layer3_remote_fetch_timeout_ms`. */
+export const LAYER3_REMOTE_FETCH_TIMEOUT_ENV = "CODEGATE_LAYER3_REMOTE_FETCH_TIMEOUT_MS";
+/** Env var name that overrides `layer3_remote_fetch_max_bytes`. */
+export const LAYER3_REMOTE_FETCH_MAX_BYTES_ENV = "CODEGATE_LAYER3_REMOTE_FETCH_MAX_BYTES";
+function normalizePositiveInteger(value) {
+    if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+        return Math.floor(value);
+    }
+    if (typeof value === "string" && value.trim().length > 0) {
+        const parsed = Number(value.trim());
+        if (Number.isFinite(parsed) && parsed > 0) {
+            return Math.floor(parsed);
+        }
+    }
+    return undefined;
+}
+function readEnvOverride(name) {
+    const raw = process.env[name];
+    if (raw === undefined) {
+        return undefined;
+    }
+    return normalizePositiveInteger(raw);
+}
 function normalizeOutputFormat(value) {
     if (!value) {
         return undefined;
@@ -351,6 +376,8 @@ export function resolveEffectiveConfig(options) {
             ...(globalConfig.suppression_rules ?? []),
             ...(projectConfig.suppression_rules ?? []),
         ],
+        layer3_remote_fetch_timeout_ms: pickFirst(readEnvOverride(LAYER3_REMOTE_FETCH_TIMEOUT_ENV), normalizePositiveInteger(projectConfig.layer3_remote_fetch_timeout_ms), normalizePositiveInteger(globalConfig.layer3_remote_fetch_timeout_ms), DEFAULT_CONFIG.layer3_remote_fetch_timeout_ms) ?? DEFAULT_CONFIG.layer3_remote_fetch_timeout_ms,
+        layer3_remote_fetch_max_bytes: pickFirst(readEnvOverride(LAYER3_REMOTE_FETCH_MAX_BYTES_ENV), normalizePositiveInteger(projectConfig.layer3_remote_fetch_max_bytes), normalizePositiveInteger(globalConfig.layer3_remote_fetch_max_bytes), DEFAULT_CONFIG.layer3_remote_fetch_max_bytes) ?? DEFAULT_CONFIG.layer3_remote_fetch_max_bytes,
     };
 }
 export function computeExitCode(findings, threshold) {

package/dist/layer3-dynamic/resource-fetcher.d.ts

@@ -8,7 +8,23 @@ export interface ResourceRequest {
 export interface ResourceFetcherOptions {
     maxRetries?: number;
     timeoutMs?: number;
+    /**
+     * Maximum number of bytes accepted in the response body. Enforced against
+     * both the declared `Content-Length` header (if present) and the running
+     * byte count during streaming read. Defaults to 1 MiB.
+     */
+    maxBytes?: number;
 }
+export declare const DEFAULT_FETCH_TIMEOUT_MS = 5000;
+export declare const DEFAULT_FETCH_MAX_BYTES = 1048576;
+/**
+ * Extract Layer 3 remote-fetch limits from the resolved CodeGate config.
+ * Kept here so callers don't have to remember the config field names.
+ */
+export declare function resourceFetcherOptionsFromConfig(config: {
+    layer3_remote_fetch_timeout_ms: number;
+    layer3_remote_fetch_max_bytes: number;
+}): ResourceFetcherOptions;
 export interface ResourceFetcherDeps {
     fetch: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
     runCommand: (command: string, args: string[]) => Promise<SandboxCommandResult>;

package/dist/layer3-dynamic/resource-fetcher.js

@@ -1,4 +1,16 @@
 import { runSandboxCommand } from "./sandbox.js";
+export const DEFAULT_FETCH_TIMEOUT_MS = 5000;
+export const DEFAULT_FETCH_MAX_BYTES = 1_048_576;
+/**
+ * Extract Layer 3 remote-fetch limits from the resolved CodeGate config.
+ * Kept here so callers don't have to remember the config field names.
+ */
+export function resourceFetcherOptionsFromConfig(config) {
+    return {
+        timeoutMs: config.layer3_remote_fetch_timeout_ms,
+        maxBytes: config.layer3_remote_fetch_max_bytes,
+    };
+}
 function defaultDeps() {
     return {
         fetch: (input, init) => fetch(input, init),
@@ -26,17 +38,87 @@ function endpointFor(request) {
     }
     return request.locator;
 }
-async function parseResponse(response) {
+/**
+ * Read a response body while enforcing `maxBytes`. Returns the collected
+ * string, or throws a tagged error if the declared `Content-Length` or the
+ * streamed size exceeds the cap.
+ */
+async function readBodyWithLimit(response, maxBytes) {
+    const declared = response.headers.get("content-length");
+    if (declared !== null) {
+        const parsed = Number(declared);
+        if (Number.isFinite(parsed) && parsed > maxBytes) {
+            // Drain & release the stream without reading bytes.
+            try {
+                await response.body?.cancel();
+            }
+            catch {
+                // no-op: cancel failures are non-fatal.
+            }
+            throw new Error(`response_too_large: declared Content-Length ${parsed} exceeds limit ${maxBytes}`);
+        }
+    }
+    const body = response.body;
+    if (!body) {
+        // No stream (e.g., HEAD or empty body): fall back to text().
+        const text = await response.text();
+        if (Buffer.byteLength(text, "utf8") > maxBytes) {
+            throw new Error(`response_too_large: body ${Buffer.byteLength(text, "utf8")} > ${maxBytes}`);
+        }
+        return text;
+    }
+    const reader = body.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            if (!value) {
+                continue;
+            }
+            total += value.byteLength;
+            if (total > maxBytes) {
+                try {
+                    await reader.cancel();
+                }
+                catch {
+                    // no-op
+                }
+                throw new Error(`response_too_large: streamed ${total} > ${maxBytes}`);
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        try {
+            reader.releaseLock();
+        }
+        catch {
+            // releaseLock throws if the reader was already cancelled; ignore.
+        }
+    }
+    const buffer = Buffer.concat(chunks.map((chunk) => Buffer.from(chunk)));
+    return buffer.toString("utf8");
+}
+async function parseResponse(response, maxBytes) {
     const contentType = response.headers.get("content-type") ?? "";
+    const text = await readBodyWithLimit(response, maxBytes);
     if (contentType.includes("application/json")) {
-        return (await response.json());
+        return JSON.parse(text);
     }
-    return await response.text();
+    return text;
 }
 function timeoutError(error) {
     const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
     return message.includes("timeout") || message.includes("aborted");
 }
+function isResponseTooLarge(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.startsWith("response_too_large");
+}
 export async function fetchResourceMetadata(request, customDeps = defaultDeps(), options = {}) {
     const deps = customDeps;
     const startedAt = deps.now();
@@ -63,13 +145,19 @@ export async function fetchResourceMetadata(request, customDeps = defaultDeps(),
         };
     }
     const endpoint = endpointFor(request);
-    const timeoutMs = options.timeoutMs ?? 5000;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS;
+    const maxBytes = options.maxBytes ?? DEFAULT_FETCH_MAX_BYTES;
     for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
         try {
             const controller = new AbortController();
             const timer = setTimeout(() => controller.abort(), timeoutMs);
-            const response = await deps.fetch(endpoint, { signal: controller.signal });
-            clearTimeout(timer);
+            let response;
+            try {
+                response = await deps.fetch(endpoint, { signal: controller.signal });
+            }
+            finally {
+                clearTimeout(timer);
+            }
             if (response.status === 401 || response.status === 403) {
                 return {
                     status: "auth_failure",
@@ -90,14 +178,24 @@ export async function fetchResourceMetadata(request, customDeps = defaultDeps(),
                     error: `HTTP ${response.status}`,
                 };
             }
+            const metadata = await parseResponse(response, maxBytes);
             return {
                 status: "ok",
                 attempts: attempt + 1,
                 elapsedMs: deps.now() - startedAt,
-                metadata: await parseResponse(response),
+                metadata,
             };
         }
         catch (error) {
+            // Size-limit breaches are deterministic — do not retry, surface as network_error.
+            if (isResponseTooLarge(error)) {
+                return {
+                    status: "network_error",
+                    attempts: attempt + 1,
+                    elapsedMs: deps.now() - startedAt,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
             if (attempt < maxRetries) {
                 await deps.sleep(100 * (attempt + 1));
                 continue;

package/dist/layer3-dynamic/tool-description-acquisition.d.ts

@@ -1,4 +1,4 @@
-import { type ResourceFetchResult, type ResourceRequest } from "./resource-fetcher.js";
+import { type ResourceFetchResult, type ResourceFetcherOptions, type ResourceRequest } from "./resource-fetcher.js";
 export interface AcquiredToolDescription {
     name: string;
     description: string;
@@ -19,4 +19,7 @@ export interface ToolDescriptionAcquisitionResult {
 export interface ToolDescriptionAcquisitionDeps {
     fetchMetadata: (request: ResourceRequest) => Promise<ResourceFetchResult>;
 }
+export interface ToolDescriptionAcquisitionOptions {
+    fetchOptions?: ResourceFetcherOptions;
+}
 export declare function acquireToolDescriptions(candidate: ToolDescriptionCandidate, customDeps?: ToolDescriptionAcquisitionDeps): Promise<ToolDescriptionAcquisitionResult>;

package/dist/layer3-dynamic/tool-description-acquisition.js

@@ -1,7 +1,7 @@
 import { fetchResourceMetadata, } from "./resource-fetcher.js";
-function defaultDeps() {
+function defaultDeps(options = {}) {
     return {
-        fetchMetadata: async (request) => fetchResourceMetadata(request),
+        fetchMetadata: async (request) => fetchResourceMetadata(request, undefined, options.fetchOptions),
     };
 }
 function parseTools(metadata) {

package/dist/layer3-dynamic/url-validation.d.ts

@@ -0,0 +1,38 @@
+/**
+ * URL validation and normalisation helpers for Layer 3 remote resource handling.
+ *
+ * These helpers guarantee that remote resources (HTTP/SSE MCP endpoints,
+ * skill-referenced URLs) use a safe, canonical form before they are fed into
+ * finding `rule_id` / `file_path` fields or into the fetcher.
+ *
+ * Historically, L3 resource IDs were composed as `${kind}:${url}` which, for
+ * http/sse kinds, produced malformed values like `http:https://mcp.linear.app/mcp`
+ * (the kind collides with the URL's own scheme). `buildResourceId` avoids that
+ * double-scheme shape by reusing the URL itself as the id for http/sse kinds.
+ */
+export type RemoteScheme = "http" | "https";
+export interface NormalizeRemoteUrlResult {
+    ok: true;
+    url: string;
+    scheme: RemoteScheme;
+}
+export interface NormalizeRemoteUrlError {
+    ok: false;
+    reason: "empty" | "unsupported_scheme" | "missing_host" | "missing_scheme" | "invalid_url";
+}
+/**
+ * Validate and canonicalise a remote URL. Rejects non http/https schemes,
+ * missing hosts, and malformed inputs. Normalises a bare-host path to a
+ * single trailing slash and strips trailing slashes from longer paths.
+ */
+export declare function normalizeRemoteUrl(input: string): NormalizeRemoteUrlResult | NormalizeRemoteUrlError;
+export type DeepScanResourceKind = "npm" | "pypi" | "git" | "http" | "sse";
+/**
+ * Build a canonical resource id used for findings (`rule_id`, `file_path`) and
+ * for consent prompts. For http/sse kinds the id is the URL itself (no
+ * `http:` / `sse:` prefix) to avoid the malformed `http:https://...` shape.
+ * For npm/pypi/git, the `<kind>:<locator>` prefix is preserved because those
+ * locators are not URLs and other code (e.g. `isRegistryMetadataResource`)
+ * keys on that prefix.
+ */
+export declare function buildResourceId(kind: DeepScanResourceKind, locator: string): string;

package/dist/layer3-dynamic/url-validation.js

@@ -0,0 +1,56 @@
+/**
+ * Validate and canonicalise a remote URL. Rejects non http/https schemes,
+ * missing hosts, and malformed inputs. Normalises a bare-host path to a
+ * single trailing slash and strips trailing slashes from longer paths.
+ */
+export function normalizeRemoteUrl(input) {
+    if (typeof input !== "string" || input.trim().length === 0) {
+        return { ok: false, reason: "empty" };
+    }
+    const trimmed = input.trim();
+    // Quick reject for bare `http:` / `https:` without `//` and host.
+    if (/^https?:\/?$/iu.test(trimmed)) {
+        return { ok: false, reason: "missing_host" };
+    }
+    // Must start with http:// or https:// (case-insensitive).
+    if (!/^https?:\/\//iu.test(trimmed)) {
+        return { ok: false, reason: "missing_scheme" };
+    }
+    let parsed;
+    try {
+        parsed = new URL(trimmed);
+    }
+    catch {
+        return { ok: false, reason: "invalid_url" };
+    }
+    const scheme = parsed.protocol.replace(":", "").toLowerCase();
+    if (scheme !== "http" && scheme !== "https") {
+        return { ok: false, reason: "unsupported_scheme" };
+    }
+    if (parsed.hostname.length === 0) {
+        return { ok: false, reason: "missing_host" };
+    }
+    // Normalise trailing slashes: keep `/` for root paths, strip for others.
+    if (parsed.pathname.length > 1 && parsed.pathname.endsWith("/")) {
+        parsed.pathname = parsed.pathname.replace(/\/+$/u, "");
+    }
+    return {
+        ok: true,
+        url: parsed.toString(),
+        scheme: scheme,
+    };
+}
+/**
+ * Build a canonical resource id used for findings (`rule_id`, `file_path`) and
+ * for consent prompts. For http/sse kinds the id is the URL itself (no
+ * `http:` / `sse:` prefix) to avoid the malformed `http:https://...` shape.
+ * For npm/pypi/git, the `<kind>:<locator>` prefix is preserved because those
+ * locators are not URLs and other code (e.g. `isRegistryMetadataResource`)
+ * keys on that prefix.
+ */
+export function buildResourceId(kind, locator) {
+    if (kind === "http" || kind === "sse") {
+        return locator;
+    }
+    return `${kind}:${locator}`;
+}

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

@@ -2,6 +2,7 @@ import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, join, relative, resolve, sep } from "node:path";
 import { collectLocalTextAnalysisTargets, } from "./layer3-dynamic/local-text-analysis.js";
+import { buildResourceId, normalizeRemoteUrl } from "./layer3-dynamic/url-validation.js";
 import { runStaticPipeline } from "./pipeline.js";
 import { applyReportSummary } from "./report-summary.js";
 import { parseConfigContent, parseConfigFile, } from "./layer1-discovery/config-parser.js";
@@ -120,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}`;
@@ -260,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;
@@ -279,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;
@@ -486,18 +539,21 @@ function collectDeepScanResourcesFromParsed(value, filePath, resources) {
                 continue;
             }
             if (typeof config.url === "string" && isHttpLikeUrl(config.url)) {
-                const kind = inferHttpKind(config.url);
-                const id = `${kind}:${config.url}`;
-                if (!resources.has(id)) {
-                    resources.set(id, {
-                        id,
-                        request: {
+                const normalized = normalizeRemoteUrl(config.url);
+                if (normalized.ok) {
+                    const kind = inferHttpKind(normalized.url);
+                    const id = buildResourceId(kind, normalized.url);
+                    if (!resources.has(id)) {
+                        resources.set(id, {
                             id,
-                            kind,
-                            locator: config.url,
-                        },
-                        commandPreview: `GET ${config.url}  (from ${filePath} -> ${container.key}.${serverName}.url)`,
-                    });
+                            request: {
+                                id,
+                                kind,
+                                locator: normalized.url,
+                            },
+                            commandPreview: `GET ${normalized.url}  (from ${filePath} -> ${container.key}.${serverName}.url)`,
+                        });
+                    }
                 }
             }
             if (Array.isArray(config.command) &&
@@ -524,8 +580,12 @@ function collectDeepScanResourcesFromParsed(value, filePath, resources) {
             if (typeof config.url !== "string" || !isHttpLikeUrl(config.url)) {
                 return;
             }
-            const kind = inferHttpKind(config.url);
-            const id = `${kind}:${config.url}`;
+            const normalized = normalizeRemoteUrl(config.url);
+            if (!normalized.ok) {
+                return;
+            }
+            const kind = inferHttpKind(normalized.url);
+            const id = buildResourceId(kind, normalized.url);
             if (resources.has(id)) {
                 return;
             }
@@ -534,9 +594,9 @@ function collectDeepScanResourcesFromParsed(value, filePath, resources) {
                 request: {
                     id,
                     kind,
-                    locator: config.url,
+                    locator: normalized.url,
                 },
-                commandPreview: `GET ${config.url}  (from ${filePath} -> ${remoteArray.key}.${index}.url)`,
+                commandPreview: `GET ${normalized.url}  (from ${filePath} -> ${remoteArray.key}.${index}.url)`,
             });
         });
     }

package/package.json

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