@zivis/mcp 0.1.0-alpha.1

package/dist/tools/discover-local-infra.js

@@ -0,0 +1,763 @@
+/**
+ * zivis_discover_local_infra — Discover AI infrastructure in a local project
+ *
+ * Reads Docker, compose, and dependency files to understand the local AI
+ * infrastructure. Returns structured recommendations for red team testing
+ * via zivis_local_scan.
+ *
+ * This is a local-only tool — no API calls or authentication required.
+ * Env values are always redacted for safety.
+ */
+import { z } from "zod";
+import { readFile, readdir, stat } from "fs/promises";
+import { join } from "path";
+import { exec } from "child_process";
+import { promisify } from "util";
+const execAsync = promisify(exec);
+// ── Constants ──
+export const DISCOVER_LOCAL_INFRA_NAME = "zivis_discover_local_infra";
+export const DISCOVER_LOCAL_INFRA_DESCRIPTION = `Discover AI infrastructure in a local project directory by reading Docker, compose, and dependency files.
+
+Analyzes the project to understand what services are defined, which are running, and what AI/LLM frameworks are in use. Returns structured recommendations for red team testing via zivis_local_scan.
+
+What it reads:
+- docker-compose.yml / docker-compose.yaml / compose.yml / compose.yaml
+- Dockerfile(s) in the project root and subdirectories
+- .env files (structure only — values are redacted for safety)
+- package.json, requirements.txt, pyproject.toml, go.mod (to detect AI frameworks)
+
+What it checks:
+- Docker daemon status
+- Currently running containers (docker compose ps)
+- Port mappings and exposed services
+
+What it returns:
+- List of services with ports and images
+- Running vs stopped status per service
+- Detected AI/LLM patterns (OpenAI, Anthropic, LangChain, etc.)
+- Suggested target_url, chat_endpoint, target_type for zivis_local_scan
+- Whether the zivis-local-runner Docker image is available
+
+This tool makes NO network requests and requires NO authentication. It only reads local files and queries the Docker daemon.`;
+export const DISCOVER_LOCAL_INFRA_SCHEMA = {
+    project_dir: z
+        .string()
+        .optional()
+        .describe("Path to the project directory to analyze. Defaults to the current working directory."),
+};
+// ── AI Framework Detection Maps ──
+const NPM_AI_PACKAGES = [
+    { package: "openai", name: "OpenAI SDK" },
+    { package: "@anthropic-ai/sdk", name: "Anthropic SDK" },
+    { package: "ai", name: "Vercel AI SDK" },
+    { package: "@ai-sdk/openai", name: "Vercel AI SDK (OpenAI)" },
+    { package: "@ai-sdk/anthropic", name: "Vercel AI SDK (Anthropic)" },
+    { package: "@langchain/core", name: "LangChain" },
+    { package: "langchain", name: "LangChain" },
+    { package: "llamaindex", name: "LlamaIndex" },
+    { package: "@azure/openai", name: "Azure OpenAI" },
+    { package: "ollama", name: "Ollama" },
+    { package: "cohere-ai", name: "Cohere" },
+    { package: "@google/generative-ai", name: "Google Gemini" },
+    { package: "@mistralai/mistralai", name: "Mistral" },
+    { package: "replicate", name: "Replicate" },
+];
+const PIP_AI_PACKAGES = [
+    { package: "openai", name: "OpenAI SDK" },
+    { package: "anthropic", name: "Anthropic SDK" },
+    { package: "langchain", name: "LangChain" },
+    { package: "llama-index", name: "LlamaIndex" },
+    { package: "transformers", name: "HuggingFace Transformers" },
+    { package: "vllm", name: "vLLM" },
+    { package: "litellm", name: "LiteLLM" },
+    { package: "guidance", name: "Microsoft Guidance" },
+    { package: "google-generativeai", name: "Google Gemini" },
+    { package: "cohere", name: "Cohere" },
+    { package: "ollama", name: "Ollama" },
+    { package: "gradio", name: "Gradio" },
+    { package: "streamlit", name: "Streamlit" },
+];
+const GO_AI_PACKAGES = [
+    { package: "sashabaranov/go-openai", name: "Go OpenAI" },
+    { package: "liushuangls/go-anthropic", name: "Go Anthropic" },
+];
+const AI_ENV_KEYS = [
+    "OPENAI_API_KEY",
+    "ANTHROPIC_API_KEY",
+    "AZURE_OPENAI_API_KEY",
+    "AZURE_OPENAI_ENDPOINT",
+    "HUGGINGFACE_TOKEN",
+    "HF_TOKEN",
+    "COHERE_API_KEY",
+    "GOOGLE_API_KEY",
+    "GOOGLE_GENERATIVE_AI_API_KEY",
+    "MISTRAL_API_KEY",
+    "REPLICATE_API_TOKEN",
+    "OLLAMA_HOST",
+    "OLLAMA_BASE_URL",
+    "LLM_MODEL",
+    "MODEL_NAME",
+    "EMBEDDING_MODEL",
+    "TOGETHER_API_KEY",
+    "GROQ_API_KEY",
+    "FIREWORKS_API_KEY",
+    "PERPLEXITY_API_KEY",
+];
+const INFRA_IMAGES = [
+    "postgres",
+    "redis",
+    "mongo",
+    "mysql",
+    "mariadb",
+    "nginx",
+    "traefik",
+    "caddy",
+    "azurite",
+    "pgadmin",
+    "adminer",
+    "mailhog",
+    "rabbitmq",
+    "kafka",
+    "zookeeper",
+    "elasticsearch",
+    "minio",
+    "vault",
+    "consul",
+    "prometheus",
+    "grafana",
+    "jaeger",
+    "memcached",
+];
+const MAX_FILE_SIZE = 100 * 1024; // 100KB cap
+// ── Handler ──
+export function createDiscoverLocalInfraHandler() {
+    return async (params) => {
+        const projectDir = params.project_dir || process.cwd();
+        const result = {
+            docker: { running: false },
+            compose: { found: false, services: [] },
+            dockerfiles: [],
+            aiFrameworks: { detected: [], envHints: [] },
+            runnerImage: { available: false },
+            suggestion: null,
+            localScanCommand: null,
+        };
+        // Step 1: Check Docker daemon
+        try {
+            const { stdout } = await execAsync("docker version --format '{{.Server.Version}}'", {
+                timeout: 5000,
+            });
+            result.docker = { running: true, version: stdout.trim().replace(/'/g, "") };
+        }
+        catch {
+            result.docker = { running: false };
+        }
+        // Step 2: Find and parse compose files (check root and common subdirs)
+        const composeFileNames = [
+            "docker-compose.yml",
+            "docker-compose.yaml",
+            "compose.yml",
+            "compose.yaml",
+        ];
+        const composeDirs = ["", "infra", "docker", "deploy", "deployment", ".docker"];
+        for (const dir of composeDirs) {
+            if (result.compose.found)
+                break;
+            for (const file of composeFileNames) {
+                const filePath = dir ? join(projectDir, dir, file) : join(projectDir, file);
+                const content = await safeReadFile(filePath);
+                if (content) {
+                    result.compose.found = true;
+                    result.compose.file = dir ? `${dir}/${file}` : file;
+                    result.compose.services = parseComposeServices(content);
+                    break;
+                }
+            }
+        }
+        // Step 3: Check running containers
+        if (result.docker.running && result.compose.found) {
+            try {
+                // Use the directory containing the compose file
+                const composeDir = result.compose.file?.includes("/")
+                    ? join(projectDir, result.compose.file.split("/").slice(0, -1).join("/"))
+                    : projectDir;
+                const { stdout } = await execAsync("docker compose ps --format json", {
+                    timeout: 10000,
+                    cwd: composeDir,
+                });
+                const runningServices = parseDockerComposePsOutput(stdout);
+                for (const svc of result.compose.services) {
+                    const running = runningServices.find((r) => r.name === svc.name || r.service === svc.name);
+                    svc.status = running ? "running" : "stopped";
+                }
+            }
+            catch {
+                // docker compose ps failed, leave statuses as unknown
+            }
+        }
+        // Step 4: Read dependency files and detect AI frameworks
+        const detected = [];
+        // package.json
+        const pkgJson = await safeReadFile(join(projectDir, "package.json"));
+        if (pkgJson) {
+            try {
+                const pkg = JSON.parse(pkgJson);
+                const allDeps = {
+                    ...pkg.dependencies,
+                    ...pkg.devDependencies,
+                };
+                for (const ai of NPM_AI_PACKAGES) {
+                    if (allDeps[ai.package]) {
+                        detected.push({
+                            name: ai.name,
+                            source: "package.json",
+                            package: ai.package,
+                            version: allDeps[ai.package],
+                        });
+                    }
+                }
+            }
+            catch {
+                // Invalid JSON, skip
+            }
+        }
+        // Search subdirectories (up to 2 levels deep) for dependency files
+        const subdirs = await safeReaddir(projectDir);
+        const searchDirs = [""];
+        for (const dir of subdirs) {
+            if (dir.startsWith(".") || dir === "node_modules" || dir === "vendor")
+                continue;
+            searchDirs.push(dir);
+            // Also check one more level (e.g., demo-app/api/, apps/api/)
+            const subSubDirs = await safeReaddir(join(projectDir, dir));
+            for (const sub of subSubDirs) {
+                if (sub.startsWith(".") || sub === "node_modules" || sub === "vendor")
+                    continue;
+                searchDirs.push(`${dir}/${sub}`);
+            }
+        }
+        for (const dir of searchDirs) {
+            const base = dir ? join(projectDir, dir) : projectDir;
+            const prefix = dir ? `${dir}/` : "";
+            // package.json
+            const subPkgJson = await safeReadFile(join(base, "package.json"));
+            if (subPkgJson) {
+                try {
+                    const pkg = JSON.parse(subPkgJson);
+                    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+                    for (const ai of NPM_AI_PACKAGES) {
+                        if (allDeps[ai.package] && !detected.some((d) => d.package === ai.package)) {
+                            detected.push({
+                                name: ai.name,
+                                source: `${prefix}package.json`,
+                                package: ai.package,
+                                version: allDeps[ai.package],
+                            });
+                        }
+                    }
+                }
+                catch {
+                    // Skip
+                }
+            }
+            // requirements.txt
+            const reqTxt = await safeReadFile(join(base, "requirements.txt"));
+            if (reqTxt) {
+                const lines = reqTxt.toLowerCase().split("\n");
+                for (const ai of PIP_AI_PACKAGES) {
+                    if (lines.some((line) => line.startsWith(ai.package) ||
+                        line.includes(`${ai.package}==`) ||
+                        line.includes(`${ai.package}>=`))) {
+                        if (!detected.some((d) => d.package === ai.package && d.source.includes(prefix))) {
+                            detected.push({
+                                name: ai.name,
+                                source: `${prefix}requirements.txt`,
+                                package: ai.package,
+                            });
+                        }
+                    }
+                }
+            }
+            // pyproject.toml
+            const pyproject = await safeReadFile(join(base, "pyproject.toml"));
+            if (pyproject) {
+                for (const ai of PIP_AI_PACKAGES) {
+                    if (pyproject.includes(`"${ai.package}"`) ||
+                        pyproject.includes(`'${ai.package}'`) ||
+                        pyproject.includes(ai.package)) {
+                        if (!detected.some((d) => d.package === ai.package)) {
+                            detected.push({
+                                name: ai.name,
+                                source: `${prefix}pyproject.toml`,
+                                package: ai.package,
+                            });
+                        }
+                    }
+                }
+            }
+            // go.mod
+            const goMod = await safeReadFile(join(base, "go.mod"));
+            if (goMod) {
+                for (const ai of GO_AI_PACKAGES) {
+                    if (goMod.includes(ai.package)) {
+                        if (!detected.some((d) => d.package === ai.package)) {
+                            detected.push({
+                                name: ai.name,
+                                source: `${prefix}go.mod`,
+                                package: ai.package,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        result.aiFrameworks.detected = detected;
+        // Step 5: Read .env files, redact values, flag AI keys
+        const envFileNames = [".env", ".env.local", ".env.development"];
+        const envHints = [];
+        // Check root and subdirs for .env files
+        for (const dir of ["", "infra", "docker"]) {
+            for (const envFile of envFileNames) {
+                const filePath = dir ? join(projectDir, dir, envFile) : join(projectDir, envFile);
+                const content = await safeReadFile(filePath);
+                if (content) {
+                    const keys = content
+                        .split("\n")
+                        .filter((line) => line.includes("=") && !line.startsWith("#"))
+                        .map((line) => line.split("=")[0].trim())
+                        .filter(Boolean);
+                    for (const key of keys) {
+                        if (AI_ENV_KEYS.some((aiKey) => key.toUpperCase().includes(aiKey) || aiKey.includes(key.toUpperCase()))) {
+                            envHints.push(key);
+                        }
+                    }
+                }
+            }
+        }
+        result.aiFrameworks.envHints = [...new Set(envHints)];
+        // Step 6: Scan for Dockerfiles (reuse searchDirs from dependency scan)
+        const dockerfiles = [];
+        for (const dir of searchDirs) {
+            const base = dir ? join(projectDir, dir) : projectDir;
+            const prefix = dir ? `${dir}/` : "";
+            const dirFiles = await safeReaddir(base);
+            for (const file of dirFiles) {
+                if (file === "Dockerfile" || file.startsWith("Dockerfile.")) {
+                    const info = await parseDockerfile(base, file);
+                    if (info) {
+                        info.path = `${prefix}${file}`;
+                        dockerfiles.push(info);
+                    }
+                }
+            }
+        }
+        result.dockerfiles = dockerfiles;
+        // Step 7: Check if local runner image exists
+        if (result.docker.running) {
+            try {
+                const { stdout } = await execAsync("docker images ghcr.io/zivisai/zivis-local-runner --format '{{.Tag}}'", { timeout: 5000 });
+                const tag = stdout.trim().replace(/'/g, "");
+                if (tag) {
+                    result.runnerImage = { available: true, tag };
+                }
+                else {
+                    result.runnerImage = {
+                        available: false,
+                        buildCommand: "cd zivis-rt && docker build -f Dockerfile.local-runner -t ghcr.io/zivisai/zivis-local-runner:latest .",
+                    };
+                }
+            }
+            catch {
+                result.runnerImage = {
+                    available: false,
+                    buildCommand: "cd zivis-rt && docker build -f Dockerfile.local-runner -t ghcr.io/zivisai/zivis-local-runner:latest .",
+                };
+            }
+        }
+        // Step 8: Generate suggestion
+        result.suggestion = generateSuggestion(result.compose.services, result.aiFrameworks.detected, result.aiFrameworks.envHints, result.dockerfiles);
+        if (result.suggestion) {
+            const parts = [`target_url="${result.suggestion.target_url}"`];
+            parts.push(`target_type="${result.suggestion.target_type}"`);
+            if (result.suggestion.chat_endpoint) {
+                parts.push(`chat_endpoint="${result.suggestion.chat_endpoint}"`);
+            }
+            if (result.suggestion.request_template) {
+                parts.push(`request_template='${result.suggestion.request_template}'`);
+            }
+            if (result.suggestion.response_path) {
+                parts.push(`response_path="${result.suggestion.response_path}"`);
+            }
+            parts.push(`scan_depth="standard"`);
+            result.localScanCommand = `zivis_local_scan(${parts.join(", ")})`;
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    };
+}
+// ── Helpers ──
+async function safeReadFile(filePath) {
+    try {
+        const stats = await stat(filePath);
+        if (stats.size > MAX_FILE_SIZE)
+            return null;
+        const content = await readFile(filePath, "utf-8");
+        return content;
+    }
+    catch {
+        return null;
+    }
+}
+async function safeReaddir(dirPath) {
+    try {
+        const entries = await readdir(dirPath);
+        return entries;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Parse a docker-compose file using line-by-line analysis.
+ * Extracts service names, images, ports, environment keys, and depends_on.
+ */
+function parseComposeServices(content) {
+    const lines = content.split("\n");
+    const services = [];
+    let inServices = false;
+    let currentService = null;
+    let currentSection = ""; // "ports", "environment", "depends_on", ""
+    let serviceIndent = -1;
+    let sectionIndent = -1;
+    for (const line of lines) {
+        const raw = line;
+        const trimmed = raw.trimEnd().trimStart();
+        if (trimmed === "" || trimmed.startsWith("#"))
+            continue;
+        const indent = raw.length - raw.trimStart().length;
+        // Top-level "services:" key (indent 0)
+        if (indent === 0 && /^services:\s*$/.test(trimmed)) {
+            inServices = true;
+            serviceIndent = -1;
+            continue;
+        }
+        // Another top-level key ends the services block
+        if (inServices && indent === 0) {
+            inServices = false;
+            if (currentService)
+                services.push(currentService);
+            currentService = null;
+            continue;
+        }
+        if (!inServices)
+            continue;
+        // Detect service names: lines at the first indent level under services
+        // that end with ":" and contain only word/dash chars
+        if (serviceIndent === -1 && /^[\w][\w.-]*:\s*$/.test(trimmed)) {
+            serviceIndent = indent;
+        }
+        if (indent === serviceIndent && /^[\w][\w.-]*:\s*$/.test(trimmed)) {
+            if (currentService)
+                services.push(currentService);
+            const name = trimmed.replace(/:\s*$/, "");
+            currentService = {
+                name,
+                ports: [],
+                status: "unknown",
+                environmentKeys: [],
+                dependsOn: [],
+            };
+            currentSection = "";
+            sectionIndent = -1;
+            continue;
+        }
+        if (!currentService)
+            continue;
+        // Service properties (indent > serviceIndent)
+        if (indent > serviceIndent) {
+            // Check for property keys
+            const propMatch = trimmed.match(/^(image|ports|environment|depends_on|build):\s*(.*)/);
+            if (propMatch) {
+                const key = propMatch[1];
+                const value = propMatch[2].trim();
+                if (key === "image" && value) {
+                    currentService.image = value.replace(/["']/g, "");
+                    currentSection = "";
+                    continue;
+                }
+                if (key === "ports" || key === "environment" || key === "depends_on") {
+                    currentSection = key;
+                    sectionIndent = indent;
+                    continue;
+                }
+                currentSection = "";
+                continue;
+            }
+            // If we're at a deeper indent than section, parse items
+            if (currentSection && sectionIndent >= 0 && indent > sectionIndent) {
+                if (trimmed.startsWith("-")) {
+                    const value = trimmed.replace(/^-\s*/, "").replace(/["']/g, "").trim();
+                    if (currentSection === "ports") {
+                        const portMatch = value.match(/(\d+):(\d+)/);
+                        if (portMatch) {
+                            currentService.ports.push({
+                                host: parseInt(portMatch[1], 10),
+                                container: parseInt(portMatch[2], 10),
+                            });
+                        }
+                    }
+                    else if (currentSection === "depends_on") {
+                        currentService.dependsOn.push(value);
+                    }
+                    else if (currentSection === "environment") {
+                        const envKey = value.split("=")[0].trim();
+                        if (envKey)
+                            currentService.environmentKeys.push(envKey);
+                    }
+                }
+                else if (currentSection === "environment" && trimmed.includes(":")) {
+                    // Environment as mapping (KEY: value)
+                    const envKey = trimmed.split(":")[0].trim();
+                    if (envKey)
+                        currentService.environmentKeys.push(envKey);
+                }
+            }
+            else if (indent <= sectionIndent) {
+                // Back to service property level, reset section
+                currentSection = "";
+                sectionIndent = -1;
+                // Re-check for property match
+                const rePropMatch = trimmed.match(/^(image|ports|environment|depends_on|build):\s*(.*)/);
+                if (rePropMatch) {
+                    const key = rePropMatch[1];
+                    const value = rePropMatch[2].trim();
+                    if (key === "image" && value) {
+                        currentService.image = value.replace(/["']/g, "");
+                    }
+                    else if (key === "ports" || key === "environment" || key === "depends_on") {
+                        currentSection = key;
+                        sectionIndent = indent;
+                    }
+                }
+            }
+        }
+    }
+    if (currentService)
+        services.push(currentService);
+    return services;
+}
+function parseDockerComposePsOutput(stdout) {
+    const containers = [];
+    // docker compose ps --format json outputs one JSON object per line
+    for (const line of stdout.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const obj = JSON.parse(trimmed);
+            containers.push({
+                name: obj.Name || obj.name || "",
+                service: obj.Service || obj.service || "",
+            });
+        }
+        catch {
+            // Not JSON, skip
+        }
+    }
+    return containers;
+}
+async function parseDockerfile(dir, filename) {
+    const content = await safeReadFile(join(dir, filename));
+    if (!content)
+        return null;
+    const info = {
+        path: filename,
+        baseImage: "",
+        exposedPorts: [],
+        aiHints: [],
+    };
+    for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        // FROM instruction
+        if (/^FROM\s+/i.test(trimmed)) {
+            const fromMatch = trimmed.match(/^FROM\s+(\S+)/i);
+            if (fromMatch && !info.baseImage) {
+                info.baseImage = fromMatch[1];
+            }
+        }
+        // EXPOSE instruction
+        if (/^EXPOSE\s+/i.test(trimmed)) {
+            const ports = trimmed
+                .replace(/^EXPOSE\s+/i, "")
+                .split(/\s+/)
+                .map((p) => parseInt(p, 10))
+                .filter((p) => !isNaN(p));
+            info.exposedPorts.push(...ports);
+        }
+        // AI hints from pip install / npm install
+        if (trimmed.includes("pip install") || trimmed.includes("pip3 install")) {
+            for (const ai of PIP_AI_PACKAGES) {
+                if (trimmed.includes(ai.package)) {
+                    info.aiHints.push(`Installs ${ai.name} (${ai.package})`);
+                }
+            }
+        }
+        if (trimmed.includes("npm install") || trimmed.includes("pnpm add") || trimmed.includes("yarn add")) {
+            for (const ai of NPM_AI_PACKAGES) {
+                if (trimmed.includes(ai.package)) {
+                    info.aiHints.push(`Installs ${ai.name} (${ai.package})`);
+                }
+            }
+        }
+        // Known AI base images
+        if (/^FROM\s+/i.test(trimmed)) {
+            const image = trimmed.replace(/^FROM\s+/i, "").split(/\s+/)[0].toLowerCase();
+            if (image.includes("ollama"))
+                info.aiHints.push("Uses Ollama base image");
+            if (image.includes("vllm"))
+                info.aiHints.push("Uses vLLM base image");
+            if (image.includes("huggingface") || image.includes("transformers"))
+                info.aiHints.push("Uses HuggingFace base image");
+        }
+    }
+    return info;
+}
+function generateSuggestion(services, frameworks, envHints, dockerfiles) {
+    const reasons = [];
+    // Filter out infrastructure services
+    const appServices = services.filter((svc) => {
+        const image = (svc.image || "").toLowerCase();
+        return !INFRA_IMAGES.some((infra) => image.includes(infra));
+    });
+    // Determine target type
+    const hasAiFrameworks = frameworks.length > 0;
+    const hasAiEnvKeys = envHints.length > 0;
+    const targetType = hasAiFrameworks || hasAiEnvKeys ? "ai_chat" : "api";
+    if (hasAiFrameworks) {
+        reasons.push(`Detected AI frameworks: ${frameworks.map((f) => f.name).join(", ")}`);
+    }
+    if (hasAiEnvKeys) {
+        reasons.push(`Found AI-related env vars: ${envHints.join(", ")}`);
+    }
+    // Find the best service to target
+    let targetPort = null;
+    // Prefer running app services with ports
+    const runningApps = appServices.filter((svc) => svc.status === "running" && svc.ports.length > 0);
+    if (runningApps.length > 0) {
+        // Pick the first one with a port in the typical app range
+        const preferred = runningApps.find((svc) => svc.ports.some((p) => p.host >= 3000 && p.host <= 9000));
+        const target = preferred || runningApps[0];
+        targetPort = target.ports[0].host;
+        reasons.push(`Service "${target.name}" is running on port ${targetPort}`);
+    }
+    else if (appServices.length > 0) {
+        // Use any app service with ports
+        const withPorts = appServices.find((svc) => svc.ports.length > 0);
+        if (withPorts) {
+            targetPort = withPorts.ports[0].host;
+            reasons.push(`Service "${withPorts.name}" has port ${targetPort} mapped`);
+        }
+    }
+    // Fallback: check Dockerfiles for EXPOSE
+    if (!targetPort) {
+        for (const df of dockerfiles) {
+            if (df.exposedPorts.length > 0) {
+                targetPort = df.exposedPorts[0];
+                reasons.push(`Dockerfile "${df.path}" exposes port ${targetPort}`);
+                break;
+            }
+        }
+    }
+    // If still no port, try common defaults
+    if (!targetPort) {
+        targetPort = 3000;
+        reasons.push("Using default port 3000 (no port mapping found)");
+    }
+    // Infer chat endpoint from frameworks
+    const chatEndpoint = inferChatEndpoint(frameworks);
+    if (chatEndpoint) {
+        reasons.push(`Inferred endpoint ${chatEndpoint} from framework detection`);
+    }
+    // Infer request template and response path
+    const { requestTemplate, responsePath } = inferRequestFormat(frameworks);
+    // Calculate confidence
+    let confidence = "low";
+    if (hasAiFrameworks && targetPort && runningApps.length > 0) {
+        confidence = "high";
+    }
+    else if (hasAiFrameworks || hasAiEnvKeys) {
+        confidence = "medium";
+    }
+    return {
+        target_url: `http://localhost:${targetPort}`,
+        target_type: targetType,
+        chat_endpoint: chatEndpoint,
+        request_template: requestTemplate,
+        response_path: responsePath,
+        confidence,
+        reasoning: reasons.join(". ") + ".",
+    };
+}
+function inferChatEndpoint(frameworks) {
+    const names = new Set(frameworks.map((f) => f.name));
+    if (names.has("Vercel AI SDK") || names.has("Vercel AI SDK (OpenAI)") || names.has("Vercel AI SDK (Anthropic)"))
+        return "/api/chat";
+    if (names.has("Ollama"))
+        return "/api/chat";
+    if (names.has("OpenAI SDK") || names.has("Azure OpenAI"))
+        return "/v1/chat/completions";
+    if (names.has("LiteLLM"))
+        return "/chat/completions";
+    if (names.has("vLLM"))
+        return "/v1/chat/completions";
+    if (names.has("Gradio"))
+        return "/api/predict";
+    // Default for any detected AI framework
+    if (frameworks.length > 0)
+        return "/api/chat";
+    return undefined;
+}
+function inferRequestFormat(frameworks) {
+    const names = new Set(frameworks.map((f) => f.name));
+    // OpenAI-compatible APIs
+    if (names.has("OpenAI SDK") ||
+        names.has("Azure OpenAI") ||
+        names.has("vLLM") ||
+        names.has("LiteLLM")) {
+        return {
+            requestTemplate: JSON.stringify({
+                model: "gpt-4",
+                messages: [{ role: "user", content: "{{message}}" }],
+            }),
+            responsePath: "choices[0].message.content",
+        };
+    }
+    // Vercel AI SDK
+    if (names.has("Vercel AI SDK") || names.has("Vercel AI SDK (OpenAI)") || names.has("Vercel AI SDK (Anthropic)")) {
+        return {
+            requestTemplate: JSON.stringify({
+                messages: [{ role: "user", content: "{{message}}" }],
+            }),
+            responsePath: undefined, // Vercel AI SDK streams by default
+        };
+    }
+    // Ollama
+    if (names.has("Ollama")) {
+        return {
+            requestTemplate: JSON.stringify({
+                model: "llama3",
+                messages: [{ role: "user", content: "{{message}}" }],
+                stream: false,
+            }),
+            responsePath: "message.content",
+        };
+    }
+    return {};
+}
+//# sourceMappingURL=discover-local-infra.js.map