codegate-ai 0.1.0

package/dist/layer1-discovery/tool-detector.js

@@ -0,0 +1,138 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, readdirSync } from "node:fs";
+import { homedir as osHomedir } from "node:os";
+import { join } from "node:path";
+import which from "which";
+const defaultDeps = {
+    platform: process.platform,
+    homedir: osHomedir(),
+    which: (binary) => which.sync(binary, { nothrow: true }) ?? undefined,
+    execVersion: (binary) => {
+        const result = spawnSync(binary, ["--version"], { encoding: "utf8" });
+        if (result.status !== 0) {
+            return null;
+        }
+        const output = `${result.stdout ?? ""}`.trim();
+        return output.length > 0 ? (output.split(/\s+/u).pop() ?? output) : null;
+    },
+    pathExists: (path) => existsSync(path),
+    listDirectory: (path) => {
+        try {
+            return readdirSync(path);
+        }
+        catch {
+            return [];
+        }
+    },
+};
+function appCandidates(tool, platform, home) {
+    if (tool === "cursor") {
+        if (platform === "darwin")
+            return ["/Applications/Cursor.app"];
+        if (platform === "linux")
+            return [join(home, ".local/share/cursor"), "/opt/cursor"];
+        return [join(home, "AppData/Local/Programs/Cursor")];
+    }
+    if (tool === "windsurf") {
+        if (platform === "darwin")
+            return ["/Applications/Windsurf.app"];
+        if (platform === "linux")
+            return [join(home, ".local/share/windsurf"), "/opt/windsurf"];
+        return [join(home, "AppData/Local/Programs/Windsurf")];
+    }
+    if (tool === "kiro") {
+        if (platform === "darwin")
+            return ["/Applications/Kiro.app"];
+        if (platform === "linux")
+            return [join(home, ".local/share/kiro"), "/opt/kiro"];
+        return [join(home, "AppData/Local/Programs/Kiro")];
+    }
+    if (tool === "jetbrains") {
+        if (platform === "darwin") {
+            return [
+                "/Applications/JetBrains Toolbox/JetBrains Toolbox.app",
+                join(home, "Library/Application Support/JetBrains/Toolbox/apps"),
+                "/Applications/IntelliJ IDEA.app",
+                "/Applications/WebStorm.app",
+                "/Applications/PyCharm.app",
+            ];
+        }
+        if (platform === "linux") {
+            return [join(home, ".local/share/JetBrains/Toolbox/apps"), "/opt/jetbrains-toolbox/apps"];
+        }
+        return [
+            join(home, "AppData/Local/JetBrains/Toolbox/apps"),
+            join(home, "AppData/Roaming/JetBrains/Toolbox/apps"),
+        ];
+    }
+    return [];
+}
+function detectCopilot(deps) {
+    const extensionsDir = join(deps.homedir, ".vscode/extensions");
+    const entries = deps.listDirectory(extensionsDir);
+    const copilot = entries.find((entry) => entry.startsWith("github.copilot-"));
+    if (!copilot) {
+        return {
+            tool: "github-copilot",
+            installed: false,
+            version: null,
+            path: null,
+            source: "none",
+        };
+    }
+    const version = copilot.split("github.copilot-")[1] ?? null;
+    return {
+        tool: "github-copilot",
+        installed: true,
+        version,
+        path: join(extensionsDir, copilot),
+        source: "extension",
+    };
+}
+function detectCliOrAppTool(tool, binary, deps, options) {
+    if (binary) {
+        const resolved = deps.which(binary);
+        if (resolved) {
+            return {
+                tool,
+                installed: true,
+                version: options.includeVersions === false ? null : deps.execVersion(binary),
+                path: resolved,
+                source: "path",
+            };
+        }
+    }
+    for (const candidate of appCandidates(tool, deps.platform, deps.homedir)) {
+        if (deps.pathExists(candidate)) {
+            return {
+                tool,
+                installed: true,
+                version: null,
+                path: candidate,
+                source: "app-bundle",
+            };
+        }
+    }
+    return {
+        tool,
+        installed: false,
+        version: null,
+        path: null,
+        source: "none",
+    };
+}
+export function detectTools(customDeps = defaultDeps, options = {}) {
+    const mappings = [
+        { tool: "claude-code", binary: "claude" },
+        { tool: "codex-cli", binary: "codex" },
+        { tool: "opencode", binary: "opencode" },
+        { tool: "cursor", binary: "cursor" },
+        { tool: "windsurf", binary: "windsurf" },
+        { tool: "kiro", binary: "kiro" },
+        { tool: "vscode", binary: "code" },
+        { tool: "jetbrains", binary: "idea" },
+    ];
+    const detections = mappings.map((entry) => detectCliOrAppTool(entry.tool, entry.binary, customDeps, options));
+    detections.push(detectCopilot(customDeps));
+    return detections;
+}

package/dist/layer2-static/detectors/command-exec.d.ts

@@ -0,0 +1,11 @@
+import type { Finding } from "../../types/finding.js";
+export interface CommandExecInput {
+    filePath: string;
+    parsed: unknown;
+    textContent: string;
+    knownSafeMcpServers: string[];
+    knownSafeFormatters: string[];
+    knownSafeLspServers: string[];
+    blockedCommands: string[];
+}
+export declare function detectCommandExecution(input: CommandExecInput): Finding[];

package/dist/layer2-static/detectors/command-exec.js

@@ -0,0 +1,343 @@
+import { buildFindingEvidence } from "../evidence.js";
+const LAUNCHERS = new Set(["npx", "uvx", "node", "python", "python3", "deno", "bun"]);
+const SHELL_META_PATTERN = /[|;&`]|[$][(]/u;
+const COMMAND_FIELD_KEYS = new Set([
+    "command",
+    "cmd",
+    "run",
+    "runcommand",
+    "script",
+    "exec",
+    "execute",
+    "shell",
+    "shellcommand",
+    "commandline",
+]);
+const TEMPLATE_COMMAND_KEYS = new Set([
+    "command",
+    "cmd",
+    "run",
+    "runcommand",
+    "script",
+    "exec",
+    "execute",
+    "shell",
+    "shellcommand",
+    "commandline",
+    "program",
+    "binary",
+    "executable",
+    "file",
+    "launcher",
+]);
+const TEMPLATE_ARGUMENT_KEYS = new Set([
+    "args",
+    "arguments",
+    "commandarguments",
+    "argv",
+    "params",
+    "parameters",
+    "commandargs",
+]);
+const IMPLICIT_COMMAND_CONTEXT_KEYS = new Set([
+    "hook",
+    "hooks",
+    "workflow",
+    "workflows",
+    "mcp",
+    "mcpserver",
+    "mcpservers",
+    "server",
+    "servers",
+    "plugin",
+    "plugins",
+    "extension",
+    "extensions",
+    "formatter",
+    "formatters",
+    "lsp",
+    "lsps",
+    "command",
+    "commands",
+    "run",
+    "exec",
+    "execute",
+    "script",
+]);
+function makeFinding(filePath, field, ruleId, severity, description, evidence) {
+    const location = { field };
+    if (typeof evidence?.line === "number") {
+        location.line = evidence.line;
+    }
+    if (typeof evidence?.column === "number") {
+        location.column = evidence.column;
+    }
+    return {
+        rule_id: ruleId,
+        finding_id: `COMMAND_EXEC-${filePath}-${field}`,
+        severity,
+        category: "COMMAND_EXEC",
+        layer: "L2",
+        file_path: filePath,
+        location,
+        description,
+        affected_tools: [
+            "claude-code",
+            "codex-cli",
+            "opencode",
+            "cursor",
+            "windsurf",
+            "github-copilot",
+        ],
+        cve: null,
+        owasp: ["ASI02", "ASI05"],
+        cwe: "CWE-78",
+        confidence: "HIGH",
+        fixable: true,
+        remediation_actions: ["remove_field", "replace_with_default"],
+        evidence: evidence?.evidence ?? null,
+        suppressed: false,
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeKey(value) {
+    return value.replace(/[^a-z0-9]/giu, "").toLowerCase();
+}
+function extractPackageFromPath(token) {
+    const normalized = token.replaceAll("\\", "/");
+    const scopedMatch = normalized.match(/node_modules\/(@[^/]+\/[^/]+)/u);
+    if (scopedMatch?.[1]) {
+        return scopedMatch[1];
+    }
+    const plainMatch = normalized.match(/node_modules\/([^/]+)/u);
+    return plainMatch?.[1] ?? null;
+}
+function extractIdentifier(tokens) {
+    for (const token of tokens) {
+        if (token.startsWith("-")) {
+            continue;
+        }
+        if (LAUNCHERS.has(token)) {
+            continue;
+        }
+        const fromPath = extractPackageFromPath(token);
+        if (fromPath) {
+            return fromPath;
+        }
+        return token;
+    }
+    return null;
+}
+function normalizeIdentifier(value) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        return "";
+    }
+    const fromPath = extractPackageFromPath(trimmed);
+    const candidate = (fromPath ?? trimmed)
+        .replaceAll("\\", "/")
+        .replace(/[#?].*$/u, "")
+        .replace(/\/+$/u, "");
+    const looksLikePackageOrTool = /^@?[a-z0-9._-]+(?:\/[a-z0-9._-]+)?$/iu.test(candidate);
+    return looksLikePackageOrTool ? candidate.toLowerCase() : candidate;
+}
+function isAllowlistedIdentifier(identifier, allowlist) {
+    const normalizedIdentifier = normalizeIdentifier(identifier);
+    if (normalizedIdentifier.length === 0) {
+        return false;
+    }
+    const normalizedAllowlist = new Set(allowlist.map((entry) => normalizeIdentifier(entry)).filter((entry) => entry.length > 0));
+    return normalizedAllowlist.has(normalizedIdentifier);
+}
+function commandTokensFromValue(value) {
+    if (typeof value === "string") {
+        const tokens = value.split(/\s+/u).filter((part) => part.length > 0);
+        return tokens.length > 0 ? tokens : null;
+    }
+    if (Array.isArray(value) && value.every((token) => typeof token === "string")) {
+        const tokens = value.map((token) => token.trim()).filter((token) => token.length > 0);
+        return tokens.length > 0 ? tokens : null;
+    }
+    return null;
+}
+function commandTokensFromTemplateObject(value) {
+    let commandTokens = null;
+    const argumentTokens = [];
+    const nestedCommandTemplates = [];
+    for (const [key, child] of Object.entries(value)) {
+        const normalizedKey = normalizeKey(key);
+        if (TEMPLATE_COMMAND_KEYS.has(normalizedKey)) {
+            const direct = commandTokensFromValue(child);
+            if (!commandTokens && direct) {
+                commandTokens = direct;
+                continue;
+            }
+            if (!commandTokens && isRecord(child)) {
+                nestedCommandTemplates.push(child);
+            }
+            continue;
+        }
+        if (TEMPLATE_ARGUMENT_KEYS.has(normalizedKey)) {
+            const parsedArgs = commandTokensFromValue(child);
+            if (parsedArgs) {
+                argumentTokens.push(...parsedArgs);
+            }
+        }
+    }
+    if (!commandTokens) {
+        for (const nested of nestedCommandTemplates) {
+            const nestedTokens = commandTokensFromTemplateObject(nested);
+            if (!nestedTokens) {
+                continue;
+            }
+            commandTokens = nestedTokens;
+            break;
+        }
+    }
+    if (!commandTokens) {
+        return null;
+    }
+    return [...commandTokens, ...argumentTokens];
+}
+function isLikelyExecutableContext(path) {
+    const segments = path.split(".").map((segment) => normalizeKey(segment));
+    return segments.some((segment) => IMPLICIT_COMMAND_CONTEXT_KEYS.has(segment));
+}
+function isAllowlisted(identifier, path, input) {
+    if (!identifier) {
+        return false;
+    }
+    if (path.includes("formatter")) {
+        return isAllowlistedIdentifier(identifier, input.knownSafeFormatters);
+    }
+    if (path.includes("lsp")) {
+        return isAllowlistedIdentifier(identifier, input.knownSafeLspServers);
+    }
+    return isAllowlistedIdentifier(identifier, input.knownSafeMcpServers);
+}
+function collectCommandEntries(value, prefix = "") {
+    if (!value || typeof value !== "object") {
+        return [];
+    }
+    const record = value;
+    const entries = [];
+    const hasExplicitCommandField = Object.keys(record).some((key) => COMMAND_FIELD_KEYS.has(normalizeKey(key)));
+    if (!hasExplicitCommandField && prefix.length > 0 && isLikelyExecutableContext(prefix)) {
+        const implicitCommandTokens = commandTokensFromTemplateObject(record);
+        if (implicitCommandTokens) {
+            entries.push({
+                path: prefix,
+                contextPath: prefix,
+                command: implicitCommandTokens,
+                context: record,
+            });
+        }
+    }
+    for (const [key, child] of Object.entries(record)) {
+        const path = prefix ? `${prefix}.${key}` : key;
+        if (COMMAND_FIELD_KEYS.has(normalizeKey(key))) {
+            const directCommandTokens = commandTokensFromValue(child);
+            if (directCommandTokens) {
+                entries.push({
+                    path,
+                    contextPath: prefix,
+                    command: directCommandTokens,
+                    context: record,
+                });
+            }
+            else if (isRecord(child)) {
+                const objectCommandTokens = commandTokensFromTemplateObject(child);
+                if (objectCommandTokens) {
+                    entries.push({
+                        path,
+                        contextPath: path,
+                        command: objectCommandTokens,
+                        context: child,
+                    });
+                }
+            }
+            continue;
+        }
+        entries.push(...collectCommandEntries(child, path));
+    }
+    return entries;
+}
+function normalizeMarkupCommandText(value) {
+    return value
+        .replace(/<[^>]+>/gu, " ")
+        .replace(/\s+/gu, " ")
+        .trim();
+}
+function collectMarkdownExecuteCommandEntries(value) {
+    const entries = [];
+    const executeCommandPattern = /<execute_command\b[^>]*>([\s\S]*?)<\/execute_command>/giu;
+    const commandPattern = /<command\b[^>]*>([\s\S]*?)<\/command>/giu;
+    let commandIndex = 0;
+    for (const executeMatch of value.matchAll(executeCommandPattern)) {
+        const block = executeMatch[1];
+        if (typeof block !== "string" || block.length === 0) {
+            continue;
+        }
+        for (const commandMatch of block.matchAll(commandPattern)) {
+            const commandText = commandMatch[1];
+            if (typeof commandText !== "string") {
+                continue;
+            }
+            const normalized = normalizeMarkupCommandText(commandText);
+            const commandTokens = commandTokensFromValue(normalized);
+            if (!commandTokens) {
+                continue;
+            }
+            const path = `markdown.execute_command.${commandIndex}`;
+            entries.push({
+                path,
+                contextPath: path,
+                command: commandTokens,
+                context: {},
+            });
+            commandIndex += 1;
+        }
+    }
+    return entries;
+}
+export function detectCommandExecution(input) {
+    const findings = [];
+    const entries = [
+        ...collectCommandEntries(input.parsed),
+        ...(typeof input.parsed === "string" ? collectMarkdownExecuteCommandEntries(input.parsed) : []),
+    ];
+    for (const entry of entries) {
+        const identifier = extractIdentifier(entry.command);
+        if (isAllowlisted(identifier, entry.path, input)) {
+            continue;
+        }
+        const commandLine = entry.command.join(" ");
+        const hasBlockedBinary = entry.command.some((token) => input.blockedCommands.includes(token));
+        const hasShellMeta = SHELL_META_PATTERN.test(commandLine);
+        const hasNetworkUtility = /\b(curl|wget|nc|ncat|socat)\b/u.test(commandLine);
+        if (hasBlockedBinary || hasShellMeta || hasNetworkUtility) {
+            const evidenceValue = `${entry.path} = ${JSON.stringify(entry.command)}`;
+            const evidence = buildFindingEvidence({
+                textContent: input.textContent,
+                jsonPaths: [entry.contextPath, entry.path],
+                searchTerms: [commandLine, ...entry.command],
+                fallbackValue: evidenceValue,
+            });
+            findings.push(makeFinding(input.filePath, entry.path, "command-exec-suspicious", "CRITICAL", `Suspicious command execution pattern detected: ${commandLine}`, evidence));
+        }
+        if ((entry.context.stdout === "ignore" || entry.context.stderr === "ignore") &&
+            (entry.path.includes("formatter") || entry.contextPath.includes("formatter"))) {
+            const stdoutField = entry.contextPath.length > 0 ? `${entry.contextPath}.stdout` : "stdout";
+            const evidence = buildFindingEvidence({
+                textContent: input.textContent,
+                jsonPaths: [stdoutField, entry.contextPath],
+                searchTerms: ["stdout", "ignore"],
+                fallbackValue: `${stdoutField} = ${JSON.stringify(entry.context.stdout)}`,
+            });
+            findings.push(makeFinding(input.filePath, stdoutField, "formatter-output-suppression", "HIGH", "Formatter output suppression hides command output", evidence));
+        }
+    }
+    return findings;
+}

package/dist/layer2-static/detectors/consent-bypass.d.ts

@@ -0,0 +1,8 @@
+import type { Finding } from "../../types/finding.js";
+export interface ConsentBypassInput {
+    filePath: string;
+    parsed: unknown;
+    textContent: string;
+    trustedApiDomains?: string[];
+}
+export declare function detectConsentBypass(input: ConsentBypassInput): Finding[];