feat: add VS Code support to MCP init

- Implemented vscodeClient with JSON config file approach
- Supports both project-local (.vscode/mcp.json) and global configs
- Adds Supabase MCP server with type: http and URL
- Merges with existing config if present
- Updated help text to mention VS Code support
- Checks for 'code' command availability

Author: Rodriguespn

cmd/mcp_init.go

@@ -13,7 +13,7 @@ var (
 		Long: `Configure the Supabase MCP server for your AI assistant clients.
 
 This command will detect installed MCP clients and guide you through the setup process.
-Currently supports: Claude Code, Cursor (with more clients coming soon).
+Currently supports: Claude Code, Cursor, VS Code (with more clients coming soon).
 
 The Supabase MCP server allows AI assistants to interact with your Supabase projects,
 providing tools for database operations, edge functions, storage, and more.
@@ -24,7 +24,8 @@ Examples:
 
   # Configure a specific client
   supabase mcp init --client claude-code
-  supabase mcp init --client cursor`,
+  supabase mcp init --client cursor
+  supabase mcp init --client vscode`,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			client, _ := cmd.Flags().GetString("client")
 			return mcpinit.Run(cmd.Context(), afero.NewOsFs(), client)

internal/mcp/init/init.go

@@ -62,9 +62,7 @@ func (b *baseClient) InstallInstructions() string {
 var clientRegistry = []Client{
 	newClaudeCodeClient(),
 	newCursorClient(),
-	// Add new clients here in the future:
-	// newVSCodeClient(),
-	// newClaudeDesktopClient(),
+	newVSCodeClient(),
 }
 
 func Run(ctx context.Context, fsys afero.Fs, clientFlag string) error {
@@ -301,6 +299,114 @@ func (c *cursorClient) Configure(ctx context.Context, fsys afero.Fs) error {
 	return nil
 }
 
+// vscodeClient implements the Client interface for VS Code
+type vscodeClient struct {
+	baseClient
+}
+
+func newVSCodeClient() *vscodeClient {
+	return &vscodeClient{
+		baseClient: baseClient{
+			name:                "vscode",
+			displayName:         "VS Code",
+			installInstructions: "Download from https://code.visualstudio.com",
+			checkInstalled: func() bool {
+				return commandExists("code")
+			},
+		},
+	}
+}
+
+func (c *vscodeClient) Configure(ctx context.Context, fsys afero.Fs) error {
+	fmt.Println("Configuring VS Code...")
+	fmt.Println()
+
+	// Prompt for config scope
+	fmt.Println("Where would you like to add the configuration?")
+	fmt.Println("  1. Project-local (in .vscode/mcp.json)")
+	fmt.Println("  2. Global (in your home directory)")
+	fmt.Print("Choice [1]: ")
+
+	var choice string
+	if _, err := fmt.Scanln(&choice); err != nil && err.Error() != "unexpected newline" {
+		return fmt.Errorf("failed to read choice: %w", err)
+	}
+	if choice == "" {
+		choice = "1"
+	}
+
+	var configPath string
+	if choice == "2" {
+		// Global config
+		homeDir, _ := os.UserHomeDir()
+		configPath = filepath.Join(homeDir, ".vscode", "mcp.json")
+	} else {
+		// Project-local config
+		cwd, _ := os.Getwd()
+		configPath = filepath.Join(cwd, ".vscode", "mcp.json")
+	}
+
+	// Prepare the Supabase MCP server config
+	supabaseConfig := map[string]interface{}{
+		"type": "http",
+		"url":  "https://mcp.supabase.com/mcp",
+	}
+
+	// Read existing config if it exists
+	var config map[string]interface{}
+	existingData, err := afero.ReadFile(fsys, configPath)
+	if err == nil && len(existingData) > 0 {
+		if err := json.Unmarshal(existingData, &config); err != nil {
+			// If existing file is invalid JSON, start fresh
+			config = make(map[string]interface{})
+		}
+	} else {
+		config = make(map[string]interface{})
+	}
+
+	// Ensure mcpServers exists
+	mcpServers, ok := config["mcpServers"].(map[string]interface{})
+	if !ok {
+		mcpServers = make(map[string]interface{})
+		config["mcpServers"] = mcpServers
+	}
+
+	// Add or update Supabase server
+	mcpServers["supabase"] = supabaseConfig
+
+	// Ensure directory exists
+	configDir := filepath.Dir(configPath)
+	if err := fsys.MkdirAll(configDir, 0755); err != nil {
+		return fmt.Errorf("failed to create config directory: %w", err)
+	}
+
+	// Write config
+	configJSON, err := json.MarshalIndent(config, "", "  ")
+	if err != nil {
+		return fmt.Errorf("failed to marshal config: %w", err)
+	}
+
+	if err := afero.WriteFile(fsys, configPath, configJSON, 0644); err != nil {
+		return fmt.Errorf("failed to write config file: %w", err)
+	}
+
+	fmt.Println()
+	fmt.Printf("✓ Successfully configured VS Code at: %s\n", configPath)
+	fmt.Println()
+	fmt.Println("Configuration added:")
+	fmt.Println(`{
+  "mcpServers": {
+    "supabase": {
+      "type": "http",
+      "url": "https://mcp.supabase.com/mcp"
+    }
+  }
+}`)
+	fmt.Println()
+	fmt.Println("The Supabase MCP server is now available in VS Code!")
+	return nil
+}
+
 // appExists checks if a macOS application is installed
 func appExists(appName string) bool {
 	if runtime.GOOS == "darwin" {
@@ -316,44 +422,3 @@ func appExists(appName string) bool {
 	}
 	return false
 }
-
-// Example: Adding a new client
-//
-// 1. Create a struct that embeds baseClient:
-//
-//    type myNewClient struct {
-//        baseClient
-//    }
-//
-// 2. Create a constructor function:
-//
-//    func newMyNewClient() *myNewClient {
-//        return &myNewClient{
-//            baseClient: baseClient{
-//                name:                "my-client",
-//                displayName:         "My Client",
-//                installInstructions: "Installation command or URL",
-//                checkInstalled: func() bool {
-//                    return commandExists("my-cli") || appExists("MyApp")
-//                },
-//            },
-//        }
-//    }
-//
-// 3. Implement the Configure method:
-//
-//    func (c *myNewClient) Configure(ctx context.Context, fsys afero.Fs) error {
-//        // Your configuration logic here
-//        // See claudeCodeClient or cursorClient for examples
-//        return nil
-//    }
-//
-// 4. Add to clientRegistry:
-//
-//    var clientRegistry = []Client{
-//        newClaudeCodeClient(),
-//        newCursorClient(),
-//        newMyNewClient(),  // Add here
-//    }
-
-