codegate-ai 0.13.0 → 0.14.1

package/dist/cli.js

@@ -17,6 +17,7 @@ import { renderTuiApp } from "./tui/app.js";
 import { executeWrapperRun } from "./wrapper.js";
 import { runRemediation as runRemediationWorkflow, } from "./layer4-remediation/remediation-runner.js";
 import { undoLatestSession } from "./commands/undo.js";
+import { runInventory } from "./commands/inventory-command.js";
 import { executeScanCommand } from "./commands/scan-command.js";
 import { executeScanContentCommand, SCAN_CONTENT_TYPES, } from "./commands/scan-content-command.js";
 import { executeSkillsWrapper, launchSkillsPassthrough, } from "./commands/skills-wrapper.js";
@@ -619,6 +620,70 @@ function addInitCommand(program, deps) {
         }
     });
 }
+const INVENTORY_SCOPES = ["user", "project", "all"];
+const INVENTORY_KINDS = ["skills", "configs", "all"];
+function addInventoryCommand(program, deps) {
+    program
+        .command("inventory")
+        .description("List the AI-tool config + skill artifacts the knowledge base knows about, resolved against this machine.")
+        .addOption(new Option("--scope <scope>", "scope filter")
+        .choices(INVENTORY_SCOPES)
+        .default("all"))
+        .addOption(new Option("--kind <kind>", "artifact kind filter")
+        .choices(INVENTORY_KINDS)
+        .default("all"))
+        .option("--only-existing", "return only items that currently exist on disk")
+        .option("--workspace <path>", "additional project-scope root (repeatable); defaults to cwd when omitted", collectRepeatable, [])
+        .addOption(new Option("--format <format>", "output format").choices(["text", "json"]).default("text"))
+        .addHelpText("after", renderExampleHelp([
+        "codegate inventory",
+        "codegate inventory --format json --kind skills --only-existing",
+        "codegate inventory --scope user --format json",
+        "codegate inventory --workspace . --workspace /path/to/other/repo",
+    ]))
+        .action((options) => {
+        try {
+            const home = deps.homeDir?.() ?? homedir();
+            const explicitWorkspaces = options.workspace ?? [];
+            const workspaces = explicitWorkspaces.length > 0
+                ? explicitWorkspaces.map((w) => resolve(deps.cwd(), w))
+                : [deps.cwd()];
+            const summary = runInventory({
+                scope: options.scope ?? "all",
+                kind: options.kind ?? "all",
+                onlyExisting: options.onlyExisting === true,
+                workspaces,
+                homeDir: home,
+            });
+            if (options.format === "json") {
+                deps.stdout(JSON.stringify(summary, null, 2));
+            }
+            else {
+                renderInventoryText(summary, deps.stdout);
+            }
+            deps.setExitCode(0);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            deps.stderr(`Inventory failed: ${message}`);
+            deps.setExitCode(3);
+        }
+    });
+}
+function collectRepeatable(value, previous) {
+    return [...previous, value];
+}
+function renderInventoryText(summary, stdout) {
+    stdout(`Knowledge base v${summary.kb_version}`);
+    stdout(`Tools: ${summary.tools.map((t) => t.name).join(", ")}`);
+    stdout(`Items: ${summary.items.length}`);
+    stdout("");
+    for (const item of summary.items) {
+        const mark = item.exists ? "✓" : "·";
+        const tag = item.kind === "skill" ? `${item.kind}:${item.type ?? "?"}` : item.kind;
+        stdout(`  ${mark} [${item.tool}] ${tag} (${item.scope}) ${item.path}`);
+    }
+}
 function addUpdateCommands(program, deps) {
     const guidance = [
         "Updates are bundled with CodeGate releases in v1/v2.",
@@ -680,6 +745,7 @@ export function createCli(version = packageJson.version ?? "0.0.0-dev", deps = d
     addRunCommand(program, version, deps);
     addUndoCommand(program, deps);
     addInitCommand(program, deps);
+    addInventoryCommand(program, deps);
     addUpdateCommands(program, deps);
     return program;
 }

package/dist/commands/inventory-command.d.ts

@@ -0,0 +1,39 @@
+/** One resolved artifact the scanner knows about. */
+export interface InventoryItem {
+    tool: string;
+    kind: "config" | "skill";
+    /** Only set for skill entries; mirrors KB `skill_paths[].type`. */
+    type?: string;
+    scope: "user" | "project";
+    /** Pattern as declared in the KB (relative, may contain wildcards). */
+    pattern: string;
+    /** Absolute resolved filesystem path (concrete, not the pattern). */
+    path: string;
+    /** True if the filesystem shows the path exists. */
+    exists: boolean;
+    risk_surface: string[];
+    /** Only populated for config entries that declare them. */
+    fields_of_interest?: Record<string, string>;
+    /** Resolution root used (e.g., the home dir or a workspace root). */
+    resolved_against: string;
+}
+export interface InventorySummary {
+    kb_version: string;
+    /** Known tools (from KB file names) with their version ranges. */
+    tools: Array<{
+        name: string;
+        version_range: string;
+    }>;
+    items: InventoryItem[];
+}
+export interface InventoryOptions {
+    scope: "user" | "project" | "all";
+    kind: "skills" | "configs" | "all";
+    onlyExisting: boolean;
+    /** Roots for project-scope resolution. Empty if project scope is skipped. */
+    workspaces: string[];
+    homeDir: string;
+    /** Optional injection for tests. */
+    kbBaseDir?: string;
+}
+export declare function runInventory(options: InventoryOptions): InventorySummary;

package/dist/commands/inventory-command.js

@@ -0,0 +1,194 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join, relative, resolve, sep } from "node:path";
+import { loadKnowledgeBase, } from "../layer1-discovery/knowledge-base.js";
+const MAX_WILDCARD_DEPTH = 8;
+const MAX_WILDCARD_MATCHES = 2000;
+export function runInventory(options) {
+    const kb = loadKnowledgeBase(options.kbBaseDir);
+    const includeConfigs = options.kind === "all" || options.kind === "configs";
+    const includeSkills = options.kind === "all" || options.kind === "skills";
+    const rawItems = [];
+    for (const entry of kb.entries) {
+        if (includeConfigs) {
+            for (const cp of entry.config_paths) {
+                rawItems.push(...resolveConfigEntry(entry.tool, cp, options));
+            }
+        }
+        if (includeSkills) {
+            for (const sp of entry.skill_paths ?? []) {
+                rawItems.push(...resolveSkillEntry(entry.tool, sp, options));
+            }
+        }
+    }
+    const items = options.onlyExisting ? rawItems.filter((item) => item.exists) : rawItems;
+    // Stable ordering: by tool, then kind, then scope, then path.
+    items.sort((a, b) => {
+        if (a.tool !== b.tool)
+            return a.tool.localeCompare(b.tool);
+        if (a.kind !== b.kind)
+            return a.kind.localeCompare(b.kind);
+        if (a.scope !== b.scope)
+            return a.scope.localeCompare(b.scope);
+        return a.path.localeCompare(b.path);
+    });
+    return {
+        kb_version: kb.schemaVersion,
+        tools: kb.entries
+            .map((entry) => ({
+            name: entry.tool,
+            version_range: entry.version_range,
+        }))
+            .sort((a, b) => a.name.localeCompare(b.name)),
+        items,
+    };
+}
+function resolveConfigEntry(tool, cp, options) {
+    if (!scopeIncluded(cp.scope, options.scope))
+        return [];
+    const roots = rootsFor(cp.scope, options);
+    const items = [];
+    for (const root of roots) {
+        items.push(...resolvePattern({
+            tool,
+            kind: "config",
+            scope: cp.scope,
+            pattern: cp.path,
+            root,
+            riskSurface: cp.risk_surface,
+            fieldsOfInterest: cp.fields_of_interest,
+        }));
+    }
+    return items;
+}
+function resolveSkillEntry(tool, sp, options) {
+    if (!scopeIncluded(sp.scope, options.scope))
+        return [];
+    const roots = rootsFor(sp.scope, options);
+    const items = [];
+    for (const root of roots) {
+        items.push(...resolvePattern({
+            tool,
+            kind: "skill",
+            type: sp.type,
+            scope: sp.scope,
+            pattern: sp.path,
+            root,
+            riskSurface: sp.risk_surface,
+        }));
+    }
+    return items;
+}
+function scopeIncluded(entryScope, optionScope) {
+    if (optionScope === "all")
+        return true;
+    return entryScope === optionScope;
+}
+function rootsFor(entryScope, options) {
+    if (entryScope === "user")
+        return [options.homeDir];
+    if (options.workspaces.length === 0)
+        return [];
+    return options.workspaces;
+}
+function resolvePattern(input) {
+    const normalized = normalizePattern(input.pattern);
+    const hasWildcard = /[*?]/.test(normalized);
+    if (!hasWildcard) {
+        const absolute = resolve(input.root, normalized);
+        return [makeItem(input, absolute, existsSync(absolute))];
+    }
+    const matches = expandWildcard(input.root, normalized);
+    return matches.map((absolute) => makeItem(input, absolute, true));
+}
+function makeItem(input, absolute, exists) {
+    return {
+        tool: input.tool,
+        kind: input.kind,
+        type: input.type,
+        scope: input.scope,
+        pattern: input.pattern,
+        path: absolute,
+        exists,
+        risk_surface: input.riskSurface,
+        fields_of_interest: input.fieldsOfInterest,
+        resolved_against: input.root,
+    };
+}
+function normalizePattern(pattern) {
+    return pattern.replace(/^~\//, "").replace(/^\/+/, "");
+}
+function escapeRegex(value) {
+    return value.replace(/[|\\{}()[\]^$+?.*]/g, "\\$&");
+}
+function wildcardToRegex(pattern) {
+    let escaped = escapeRegex(pattern);
+    escaped = escaped.replace(/\\\*\\\*\//g, "(?:[^/]+/)*");
+    escaped = escaped.replace(/\\\*\\\*/g, ".*");
+    escaped = escaped.replace(/\\\*/g, "[^/]*");
+    escaped = escaped.replace(/\\\?/g, "[^/]");
+    return new RegExp(`^${escaped}$`);
+}
+function fixedPrefix(pattern) {
+    const firstStar = pattern.indexOf("*");
+    const firstQuestion = pattern.indexOf("?");
+    const firstWildcard = firstStar === -1
+        ? firstQuestion
+        : firstQuestion === -1
+            ? firstStar
+            : Math.min(firstStar, firstQuestion);
+    if (firstWildcard === -1)
+        return pattern;
+    const prefix = pattern.slice(0, firstWildcard);
+    const lastSlash = prefix.lastIndexOf("/");
+    return lastSlash === -1 ? "" : prefix.slice(0, lastSlash);
+}
+function expandWildcard(root, pattern) {
+    const matchRegex = wildcardToRegex(pattern);
+    const prefix = fixedPrefix(pattern);
+    const baseDir = prefix ? resolve(root, prefix) : resolve(root);
+    if (!existsSync(baseDir))
+        return [];
+    try {
+        if (!statSync(baseDir).isDirectory())
+            return [];
+    }
+    catch {
+        return [];
+    }
+    const matches = [];
+    const queue = [{ dir: baseDir, depth: 0 }];
+    while (queue.length > 0 && matches.length < MAX_WILDCARD_MATCHES) {
+        const current = queue.pop();
+        if (!current)
+            break;
+        let entries;
+        try {
+            entries = readdirSync(current.dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (matches.length >= MAX_WILDCARD_MATCHES)
+                break;
+            const absolute = join(current.dir, entry.name);
+            if (entry.isSymbolicLink())
+                continue;
+            if (entry.isDirectory()) {
+                if (current.depth < MAX_WILDCARD_DEPTH) {
+                    queue.push({ dir: absolute, depth: current.depth + 1 });
+                }
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            const rel = relative(root, absolute).split(sep).join("/");
+            if (rel.startsWith(".."))
+                continue;
+            if (!matchRegex.test(rel))
+                continue;
+            matches.push(absolute);
+        }
+    }
+    return matches;
+}

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/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";
@@ -486,18 +487,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 +528,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 +542,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.13.0",
+  "version": "0.14.1",
   "description": "Pre-flight security scanner for AI coding tool configurations.",
   "license": "MIT",
   "type": "module",