Merge pull request #727 from safedep/feat/antigravity-support

feat: vscode and antigravity support in endpoint scan

Author: KunalSin9h

pkg/aitool/ai_extension.go

@@ -13,10 +13,11 @@ import (
 // ideNameFromPath extracts the IDE name from an extensions.json path.
 // e.g. "/home/user/.vscode/extensions/extensions.json" → "VS Code"
 var ideDirNames = map[string]string{
-	".vscode":     "VS Code",
-	".vscode-oss": "VSCodium",
-	".cursor":     "Cursor",
-	".windsurf":   "Windsurf",
+	".vscode":      "VS Code",
+	".vscode-oss":  "VSCodium",
+	".cursor":      "Cursor",
+	".windsurf":    "Windsurf",
+	".antigravity": "Antigravity",
 }
 
 const (

pkg/aitool/antigravity.go

@@ -0,0 +1,89 @@
+package aitool
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+)
+
+const (
+	antigravityApp        = "antigravity"
+	antigravityAppDisplay = "Antigravity"
+)
+
+type antigravityDiscoverer struct {
+	homeDir string
+	config  DiscoveryConfig
+}
+
+// NewAntigravityDiscoverer creates an Antigravity config discoverer.
+func NewAntigravityDiscoverer(config DiscoveryConfig) (AIToolReader, error) {
+	homeDir := config.HomeDir
+	if homeDir == "" {
+		var err error
+		homeDir, err = os.UserHomeDir()
+		if err != nil {
+			return nil, err
+		}
+	}
+	return &antigravityDiscoverer{
+		homeDir: homeDir,
+		config:  config,
+	}, nil
+}
+
+func (d *antigravityDiscoverer) Name() string { return "Antigravity Config" }
+func (d *antigravityDiscoverer) App() string  { return antigravityApp }
+
+func (d *antigravityDiscoverer) EnumTools(_ context.Context, handler AIToolHandlerFn) error {
+	if !d.config.ScopeEnabled(AIToolScopeSystem) {
+		return nil
+	}
+
+	// ~/.gemini/antigravity/mcp_config.json holds global MCP server config.
+	systemMCPPath := filepath.Join(d.homeDir, ".gemini", "antigravity", "mcp_config.json")
+	if cfg, err := parseMCPAppConfig(systemMCPPath); err == nil {
+		if err := emitMCPServers(cfg, systemMCPPath, AIToolScopeSystem, antigravityApp, antigravityAppDisplay, handler); err != nil {
+			return err
+		}
+	}
+
+	// Emit coding_agent for the first known Antigravity data directory found.
+	// Linux/macOS: ~/.antigravity (legacy), ~/.config/Antigravity (XDG config),
+	// ~/.local/share/antigravity (XDG data).
+	// Windows: %APPDATA%\Antigravity, %LOCALAPPDATA%\Antigravity.
+	// os.Getenv returns "" on platforms where the variable is absent, causing
+	// filepath.Join to produce a relative path that os.Stat will not find — the
+	// directory is simply skipped.
+	agDirs := []string{
+		filepath.Join(d.homeDir, ".antigravity"),
+		filepath.Join(d.homeDir, ".config", "Antigravity"),
+		filepath.Join(d.homeDir, ".local", "share", "antigravity"),
+		filepath.Join(os.Getenv("APPDATA"), "Antigravity"),
+		filepath.Join(os.Getenv("LOCALAPPDATA"), "Antigravity"),
+	}
+	for _, dir := range agDirs {
+		info, err := os.Stat(dir)
+		if err != nil || !info.IsDir() {
+			continue
+		}
+		agent := &AITool{
+			Name:       "Antigravity",
+			Type:       AIToolTypeCodingAgent,
+			Scope:      AIToolScopeSystem,
+			App:        antigravityApp,
+			AppDisplay: antigravityAppDisplay,
+			ConfigPath: dir,
+			Agent:      &AgentConfig{},
+		}
+		agent.ID = generateID(agent.App, string(agent.Type), string(agent.Scope), agent.Name, agent.ConfigPath)
+		agent.SourceID = generateSourceID(agent.App, agent.ConfigPath)
+
+		if err := handler(agent); err != nil {
+			return err
+		}
+		break
+	}
+
+	return nil
+}

pkg/aitool/antigravity_cli.go

@@ -0,0 +1,26 @@
+package aitool
+
+import "strings"
+
+type antigravityCLIVerifier struct{}
+
+func (d *antigravityCLIVerifier) BinaryNames() []string { return []string{"antigravity", "ag-kit"} }
+func (d *antigravityCLIVerifier) VerifyArgs() []string  { return []string{"--version"} }
+func (d *antigravityCLIVerifier) DisplayName() string   { return "Antigravity" }
+func (d *antigravityCLIVerifier) App() string           { return antigravityApp }
+
+func (d *antigravityCLIVerifier) VerifyOutput(stdout, stderr string) (string, bool) {
+	// Output format: "1.107.0\n<commit-hash>\n<arch>"
+	// Version is on the first line.
+	combined := stdout + stderr
+	firstLine := strings.SplitN(combined, "\n", 2)[0]
+	if m := semverLineRe.FindStringSubmatch(strings.TrimSpace(firstLine)); len(m) > 1 {
+		return m[1], true
+	}
+	return "", false
+}
+
+// NewAntigravityCLIDiscoverer creates a discoverer for the Antigravity CLI binary.
+func NewAntigravityCLIDiscoverer(config DiscoveryConfig) (AIToolReader, error) {
+	return &cliToolDiscoverer{verifier: &antigravityCLIVerifier{}, config: config}, nil
+}

pkg/aitool/antigravity_test.go

@@ -0,0 +1,107 @@
+package aitool
+
+import (
+	"context"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestAntigravityDiscoverer_WithFixtures(t *testing.T) {
+	fixtures := fixturesDir(t)
+	tmpDir := t.TempDir()
+
+	err := copyDir(
+		filepath.Join(fixtures, "antigravity-gemini"),
+		filepath.Join(tmpDir, ".gemini", "antigravity"),
+	)
+	require.NoError(t, err)
+
+	err = mkdir(filepath.Join(tmpDir, ".antigravity"))
+	require.NoError(t, err)
+
+	reader, err := NewAntigravityDiscoverer(DiscoveryConfig{HomeDir: tmpDir})
+	require.NoError(t, err)
+
+	var tools []*AITool
+	err = reader.EnumTools(context.Background(), func(tool *AITool) error {
+		tools = append(tools, tool)
+		return nil
+	})
+	require.NoError(t, err)
+	assert.NotEmpty(t, tools)
+
+	var systemMCP []*AITool
+	for _, tool := range tools {
+		if tool.Type == AIToolTypeMCPServer && tool.Scope == AIToolScopeSystem {
+			systemMCP = append(systemMCP, tool)
+		}
+	}
+	require.NotEmpty(t, systemMCP)
+	assert.Equal(t, "ag-server", systemMCP[0].Name)
+	assert.Equal(t, antigravityApp, systemMCP[0].App)
+	assert.Equal(t, MCPTransportStreamableHTTP, systemMCP[0].MCPServer.Transport)
+
+	var agents []*AITool
+	for _, tool := range tools {
+		if tool.Type == AIToolTypeCodingAgent {
+			agents = append(agents, tool)
+		}
+	}
+	require.Len(t, agents, 1)
+	assert.Equal(t, "Antigravity", agents[0].Name)
+	assert.Equal(t, antigravityApp, agents[0].App)
+	assert.Equal(t, AIToolScopeSystem, agents[0].Scope)
+}
+
+func TestAntigravityDiscoverer_MissingConfig(t *testing.T) {
+	reader, err := NewAntigravityDiscoverer(DiscoveryConfig{HomeDir: t.TempDir()})
+	require.NoError(t, err)
+
+	var tools []*AITool
+	err = reader.EnumTools(context.Background(), func(tool *AITool) error {
+		tools = append(tools, tool)
+		return nil
+	})
+	assert.NoError(t, err)
+	assert.Empty(t, tools)
+}
+
+func TestAntigravityDiscoverer_DirExistsButNoMCPJson(t *testing.T) {
+	tmpDir := t.TempDir()
+	require.NoError(t, mkdir(filepath.Join(tmpDir, ".antigravity")))
+
+	reader, err := NewAntigravityDiscoverer(DiscoveryConfig{HomeDir: tmpDir})
+	require.NoError(t, err)
+
+	var tools []*AITool
+	err = reader.EnumTools(context.Background(), func(tool *AITool) error {
+		tools = append(tools, tool)
+		return nil
+	})
+	require.NoError(t, err)
+	require.Len(t, tools, 1)
+	assert.Equal(t, AIToolTypeCodingAgent, tools[0].Type)
+	assert.Equal(t, "Antigravity", tools[0].Name)
+}
+
+func TestAntigravityDiscoverer_NoDuplicateCodingAgent(t *testing.T) {
+	tmpDir := t.TempDir()
+	require.NoError(t, mkdir(filepath.Join(tmpDir, ".antigravity")))
+	require.NoError(t, mkdir(filepath.Join(tmpDir, ".config", "Antigravity")))
+
+	reader, err := NewAntigravityDiscoverer(DiscoveryConfig{HomeDir: tmpDir})
+	require.NoError(t, err)
+
+	var agents []*AITool
+	err = reader.EnumTools(context.Background(), func(tool *AITool) error {
+		if tool.Type == AIToolTypeCodingAgent {
+			agents = append(agents, tool)
+		}
+		return nil
+	})
+	require.NoError(t, err)
+	assert.Len(t, agents, 1, "should emit only one coding_agent even when multiple dirs exist")
+}

pkg/aitool/fixtures/antigravity-gemini/mcp_config.json

@@ -0,0 +1,7 @@
+{
+  "mcpServers": {
+    "ag-server": {
+      "serverUrl": "https://mcp.example.com/mcp"
+    }
+  }
+}

pkg/aitool/fixtures/vscode-project/mcp.json

@@ -0,0 +1,8 @@
+{
+  "servers": {
+    "vscode-project-tool": {
+      "command": "python",
+      "args": ["tool.py"]
+    }
+  }
+}

pkg/aitool/fixtures/vscode/mcp.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "vscode-global": {
+      "command": "node",
+      "args": ["server.js"]
+    }
+  }
+}

pkg/aitool/mcp_config.go

@@ -2,6 +2,7 @@ package aitool
 
 import (
 	"encoding/json"
+	"maps"
 	"os"
 	"sort"
 	"strings"
@@ -35,8 +36,11 @@ func (e mcpServerEntry) resolvedURL() string {
 // mcpAppConfig represents an application's JSON config file containing
 // MCP servers. The Permissions and Model fields are used by Claude Code;
 // other apps ignore them during JSON unmarshaling.
+// VS Code (and Antigravity project files) use "servers" as the top-level key
+// instead of "mcpServers"; both are read and merged during emit.
 type mcpAppConfig struct {
 	MCPServers  map[string]mcpServerEntry `json:"mcpServers,omitempty"`
+	Servers     map[string]mcpServerEntry `json:"servers,omitempty"`
 	Permissions map[string]any            `json:"permissions,omitempty"`
 	Model       string                    `json:"model,omitempty"`
 }
@@ -84,9 +88,14 @@ func detectTransport(entry mcpServerEntry) MCPTransport {
 }
 
 // emitMCPServers creates and emits AITool entries for all MCP servers in a config.
+// Entries from "mcpServers" and "servers" are merged; "mcpServers" takes precedence
+// when the same name appears in both.
 func emitMCPServers(cfg *mcpAppConfig, configPath string, scope AIToolScope, app, appDisplay string, handler AIToolHandlerFn) error {
-	for _, name := range sortedKeys(cfg.MCPServers) {
-		entry := cfg.MCPServers[name]
+	merged := make(map[string]mcpServerEntry, len(cfg.MCPServers)+len(cfg.Servers))
+	maps.Copy(merged, cfg.Servers)
+	maps.Copy(merged, cfg.MCPServers)
+	for _, name := range sortedKeys(merged) {
+		entry := merged[name]
 
 		transport := detectTransport(entry)
 

pkg/aitool/registry.go

@@ -79,11 +79,15 @@ func DefaultRegistry() *Registry {
 	r.Register("claude_code_config", NewClaudeCodeDiscoverer)
 	r.Register("cursor_config", NewCursorDiscoverer)
 	r.Register("windsurf_config", NewWindsurfDiscoverer)
+	r.Register("antigravity_config", NewAntigravityDiscoverer)
+	r.Register("vscode_config", NewVSCodeDiscoverer)
 
 	// CLI tool discoverers
 	r.Register("claude_code_cli", NewClaudeCLIDiscoverer)
 	r.Register("cursor_cli", NewCursorCLIDiscoverer)
 	r.Register("windsurf_cli", NewWindsurfCLIDiscoverer)
+	r.Register("antigravity_cli", NewAntigravityCLIDiscoverer)
+	r.Register("vscode_cli", NewVSCodeCLIDiscoverer)
 	r.Register("aider", NewAiderDiscoverer)
 	r.Register("gh_copilot", NewGhCopilotDiscoverer)
 	r.Register("amazon_q", NewAmazonQDiscoverer)