agentshield/adapter/gpt_actions/

mod.rs

//! GPT Actions adapter.
//!
//! Detects OpenAPI specs used by ChatGPT custom actions (GPTs / plugin manifests)
//! and loads each path+method combination as a `ToolSurface`. Server URLs are
//! emitted as `NetworkOperation` entries so SSRF detectors can evaluate them.

pub mod auth;
pub mod endpoints;
pub mod openapi;

use std::path::Path;

use crate::config::ScanPathFilter;
use crate::error::Result;
use crate::ir::execution_surface::ExecutionSurface;
use crate::ir::taint_builder::build_data_surface;
use crate::ir::tool_surface::ToolSurface;
use crate::ir::*;

pub(crate) use endpoints::{extract_openai_tools_json, extract_path_tools, extract_server_urls};
pub(crate) use openapi::{
    OPENAI_TOOL_FILENAMES, OPENAPI_FILENAMES, collect_spec_source_files, find_openapi_spec,
    has_plugin_manifest, parse_openapi_spec,
};

/// GPT Actions and OpenAI Tools adapter.
///
/// Detects OpenAPI specs and OpenAI tool/function schemas by looking for:
/// - `ai-plugin.json` (legacy ChatGPT plugin manifest)
/// - `.well-known/ai-plugin.json`
/// - `openapi.json` / `openapi.yaml` / `swagger.json` / `swagger.yaml`
/// - `tools.json` / `functions.json` / `assistant.json`
/// - `actions.json`
pub struct GptActionsAdapter;

impl super::Adapter for GptActionsAdapter {
    fn framework(&self) -> Framework {
        Framework::GptActions
    }

    fn detect(&self, root: &Path) -> bool {
        // Legacy plugin manifest at root or .well-known/
        if has_plugin_manifest(root) {
            return true;
        }

        // OpenAPI / Swagger specs
        for filename in OPENAPI_FILENAMES {
            let path = root.join(filename);
            if path.exists() {
                if let Ok(content) = std::fs::read_to_string(&path) {
                    if content.contains("x-openai-")
                        || content.contains("x-openai")
                        || content.contains("\"openapi\"")
                        || content.contains("openapi:")
                        || content.contains("\"swagger\"")
                        || content.contains("swagger:")
                    {
                        return true;
                    }
                }
            }
        }

        // OpenAI tools/functions definitions
        for filename in OPENAI_TOOL_FILENAMES {
            let path = root.join(filename);
            if path.exists() {
                if let Ok(content) = std::fs::read_to_string(&path) {
                    if content.contains("\"function\"")
                        || content.contains("\"parameters\"")
                        || content.contains("parameters:")
                    {
                        return true;
                    }
                }
            }
        }

        false
    }

    fn load(&self, root: &Path, ignore_tests: bool) -> Result<Vec<ScanTarget>> {
        let filter = ScanPathFilter::for_ignore_tests(ignore_tests);
        self.load_with_filter(root, &filter)
    }

    fn load_with_filter(&self, root: &Path, filter: &ScanPathFilter) -> Result<Vec<ScanTarget>> {
        let name = root
            .file_name()
            .map(|n| n.to_string_lossy().to_string())
            .unwrap_or_else(|| "gpt-actions".into());

        let mut tools: Vec<ToolSurface> = Vec::new();
        let mut execution = ExecutionSurface::default();

        // Find the OpenAPI spec (prefer openapi.json, then others)
        let spec_path = find_openapi_spec(root, filter);

        if let Some(spec_path) = spec_path {
            if let Ok(spec) = parse_openapi_spec(&spec_path) {
                // Extract server URLs as network operations
                extract_server_urls(&spec, &spec_path, &mut execution);

                // Extract paths as tool surfaces
                extract_path_tools(&spec, &spec_path, &mut tools);

                // Extract security schemes
                auth::extract_security_schemes(&spec, &spec_path, &mut execution);
            }
        }

        // Extract OpenAI function/tool definitions
        for filename in OPENAI_TOOL_FILENAMES {
            let tool_path = root.join(filename);
            if tool_path.exists() && filter.allows_path(root, &tool_path) {
                if let Ok(content) = std::fs::read_to_string(&tool_path) {
                    if let Ok(val) = serde_json::from_str::<serde_json::Value>(&content) {
                        extract_openai_tools_json(&val, &tool_path, &mut tools);
                    } else if let Ok(val) = serde_yaml::from_str::<serde_json::Value>(&content) {
                        extract_openai_tools_json(&val, &tool_path, &mut tools);
                    }
                }
            }
        }

        let source_files = collect_spec_source_files(root, filter);
        let dependencies = super::mcp::parse_dependencies(root, filter);
        let provenance = super::mcp::parse_provenance(root, filter);
        let data = build_data_surface(&tools, &execution);

        Ok(vec![ScanTarget {
            name,
            framework: Framework::GptActions,
            root_path: root.to_path_buf(),
            tools,
            execution,
            data,
            dependencies,
            provenance,
            source_files,
        }])
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::adapter::Adapter;
    use std::path::PathBuf;

    #[test]
    fn test_extract_openai_tools_json() {
        let schema_json = serde_json::json!([
            {
                "type": "function",
                "function": {
                    "name": "search_database",
                    "description": "Query the database for records",
                    "parameters": {
                        "type": "object",
                        "properties": {
                            "query": { "type": "string" }
                        }
                    }
                }
            }
        ]);

        let mut tools = Vec::new();
        extract_openai_tools_json(&schema_json, Path::new("tools.json"), &mut tools);
        assert_eq!(tools.len(), 1);
        assert_eq!(tools[0].name, "search_database");
        assert_eq!(
            tools[0].description.as_deref(),
            Some("Query the database for records")
        );
        assert!(tools[0].input_schema.is_some());
    }

    fn fixture_dir() -> PathBuf {
        PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/gpt_actions")
    }

    #[test]
    fn test_detect_gpt_actions() {
        let dir = fixture_dir();
        let adapter = GptActionsAdapter;
        assert!(
            adapter.detect(&dir),
            "should detect GPT Actions fixture with ai-plugin.json + openapi.json"
        );
    }

    #[test]
    fn test_detect_non_gpt_project() {
        let dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
            .join("tests/fixtures/mcp_servers/safe_calculator");
        let adapter = GptActionsAdapter;
        assert!(
            !adapter.detect(&dir),
            "should not detect GPT Actions in an MCP calculator fixture"
        );
    }

    #[test]
    fn test_load_gpt_actions_tools() {
        let dir = fixture_dir();
        let adapter = GptActionsAdapter;
        let targets = adapter.load(&dir, false).unwrap();
        assert_eq!(targets.len(), 1);

        let target = &targets[0];
        assert_eq!(target.framework, Framework::GptActions);

        // Fixture has /forecast (GET) and /alerts (GET) = 2 tools
        assert!(
            target.tools.len() >= 2,
            "expected at least 2 tools from openapi.json paths, got {}",
            target.tools.len()
        );

        // Tool names follow "{method}_{path}" format
        let tool_names: Vec<&str> = target.tools.iter().map(|t| t.name.as_str()).collect();
        assert!(
            tool_names.contains(&"get_/forecast"),
            "expected 'get_/forecast' tool"
        );
        assert!(
            tool_names.contains(&"get_/alerts"),
            "expected 'get_/alerts' tool"
        );
    }

    #[test]
    fn test_load_gpt_actions_input_schema() {
        let dir = fixture_dir();
        let adapter = GptActionsAdapter;
        let targets = adapter.load(&dir, false).unwrap();
        let target = &targets[0];

        // /forecast has parameters: location (required), days (optional)
        let forecast_tool = target
            .tools
            .iter()
            .find(|t| t.name == "get_/forecast")
            .expect("get_/forecast tool not found");

        let schema = forecast_tool
            .input_schema
            .as_ref()
            .expect("input_schema should be present");
        let props = schema
            .get("properties")
            .and_then(|v| v.as_object())
            .expect("properties should be an object");

        assert!(
            props.contains_key("location"),
            "expected 'location' parameter"
        );
        assert!(props.contains_key("days"), "expected 'days' parameter");
    }

    #[test]
    fn test_load_gpt_actions_network_operations() {
        let dir = fixture_dir();
        let adapter = GptActionsAdapter;
        let targets = adapter.load(&dir, false).unwrap();
        let target = &targets[0];

        // openapi.json has servers: [{ url: "https://api.weather.example.com" }]
        assert!(
            !target.execution.network_operations.is_empty(),
            "expected network operations from servers array"
        );

        let server_url = target
            .execution
            .network_operations
            .iter()
            .find(|op| matches!(&op.url_arg, ArgumentSource::Literal(u) if u.contains("weather.example.com")));
        assert!(
            server_url.is_some(),
            "expected weather.example.com server URL"
        );
    }

    #[test]
    fn test_load_gpt_actions_source_files() {
        let dir = fixture_dir();
        let adapter = GptActionsAdapter;
        let targets = adapter.load(&dir, false).unwrap();
        let target = &targets[0];

        // Should include openapi.json and ai-plugin.json
        assert!(
            !target.source_files.is_empty(),
            "expected source files from fixture directory"
        );

        let file_names: Vec<String> = target
            .source_files
            .iter()
            .map(|sf| {
                sf.path
                    .file_name()
                    .unwrap_or_default()
                    .to_string_lossy()
                    .to_string()
            })
            .collect();

        assert!(
            file_names.contains(&"openapi.json".to_string()),
            "expected openapi.json in source files"
        );
    }
}