vagrant_utm 0.1.1 → 0.1.3

data/lib/vagrant_utm/driver/version_4_6.rb

@@ -13,6 +13,25 @@ module VagrantPlugins
           @logger = Log4r::Logger.new("vagrant::provider::utm::version_4_6")
         end
 
+        # Implement clear_shared_folders
+        def clear_shared_folders
+          # Get the list of shared folders
+          shared_folders = read_shared_folders
+          # Get the args to remove the shared folders
+          script_path = @script_path.join("read_shared_folders_args.js")
+          cmd = ["osascript", script_path.to_s, @uuid, "--ids", shared_folders.join(",")]
+          output = execute_shell(*cmd)
+          result = JSON.parse(output)
+          return unless result["status"]
+
+          # Flatten the list of args and build the command
+          sf_args = result["result"].flatten
+          return unless sf_args.any?
+
+          command = ["remove_qemu_additional_args.applescript", @uuid, "--args", *sf_args]
+          execute_osa_script(command)
+        end
+
         def import(utm)
           utm = Vagrant::Util::Platform.windows_path(utm)
 
@@ -36,6 +55,54 @@ module VagrantPlugins
           command = ["export_vm.applescript", @uuid, path]
           execute_osa_script(command)
         end
+
+        def read_shared_folders
+          @logger.debug("Reading shared folders")
+          script_path = @script_path.join("read_shared_folders.js")
+          cmd = ["osascript", script_path.to_s, @uuid]
+          output = execute_shell(*cmd)
+          result = JSON.parse(output)
+          return unless result["status"]
+
+          # Return the list of shared folders names(id)
+          result["result"]
+        end
+
+        def share_folders(folders)
+          # sync folder cleanup will call clear_shared_folders
+          # This is just a precaution, to make sure we don't
+          # have duplicate shared folders
+          shared_folders = read_shared_folders
+          @logger.debug("Shared folders: #{shared_folders}")
+          @logger.debug("Sharing folders: #{folders}")
+
+          folders.each do |folder|
+            # Skip if the folder is already shared
+            next if shared_folders.include?(folder[:name])
+
+            args = ["--id", folder[:name],
+                    "--dir", folder[:hostpath]]
+            command = ["add_folder_share.applescript", @uuid, *args]
+            execute_osa_script(command)
+          end
+        end
+
+        def unshare_folders(folders)
+          @logger.debug("Unsharing folder: #{folder[:name]}")
+          # Get the args to remove the shared folders
+          script_path = @script_path.join("read_shared_folders_args.js")
+          cmd = ["osascript", script_path.to_s, @uuid, "--ids", folders.join(",")]
+          output = execute_shell(*cmd)
+          result = JSON.parse(output)
+          return unless result["status"]
+
+          # Flatten the list of args and build the command
+          sf_args = result["result"].flatten
+          return unless sf_args.any?
+
+          command = ["remove_qemu_additional_args.applescript", @uuid, "--args", *sf_args]
+          execute_osa_script(command)
+        end
       end
     end
   end

data/lib/vagrant_utm/plugin.rb

@@ -33,6 +33,12 @@ module VagrantPlugins
         Config
       end
 
+      # Register the synced folder implementation
+      synced_folder(:utm) do
+        require_relative "synced_folder"
+        SyncedFolder
+      end
+
       # Register capabilities
       provider_capability(:utm, :forwarded_ports) do
         require_relative "cap"
@@ -44,6 +50,21 @@ module VagrantPlugins
         Cap
       end
 
+      synced_folder_capability(:utm, "mount_options") do
+        require_relative "cap/mount_options"
+        Cap::MountOptions
+      end
+
+      synced_folder_capability(:utm, "mount_type") do
+        require_relative "cap/mount_options"
+        Cap::MountOptions
+      end
+
+      synced_folder_capability(:utm, "mount_name") do
+        require_relative "cap/mount_options"
+        Cap::MountOptions
+      end
+
       # Register the command
       ## Start machine as a snapshot and do not save changes to disk
       command "disposable" do

data/lib/vagrant_utm/scripts/add_folder_share.applescript

@@ -0,0 +1,96 @@
+---
+-- add_directory_share.applescript
+-- This script adds QEMU arguments for directory sharing in UTM (QEMU) for given id and directory pairs.
+-- Usage: osascript add_directory_share.applescript UUID --id <ID1> --dir <DIR1> --id <ID2> --dir <DIR2> ...
+-- Example: osascript add_directory_share.applescript UUID --id no1 --dir "/path/to/dir1" --id no2 --dir "/path/to/dir2"
+
+-- Function to create QEMU arguments for directory sharing
+on createQemuArgsForDir(dirId, dirPath)
+
+    -- Prepare the QEMU argument strings
+    set fsdevArgStr to "-fsdev local,id=" & dirId & ",path=" & dirPath & ",security_model=mapped-xattr" 
+    set deviceArgStr to "-device virtio-9p-pci,fsdev=" & dirId & ",mount_tag=" & dirId
+
+    return {fsdevArgStr, deviceArgStr}
+end createQemuArgsForDir
+
+-- Main script
+on run argv
+    -- VM id is assumed to be the first argument
+    set vmId to item 1 of argv 
+
+    -- Initialize variables
+    set idList to {} -- 
+    set dirList to {}
+    set idFlag to false
+    set dirFlag to false
+
+    -- Parse arguments
+    repeat with i from 2 to (count of argv)
+        set currentArg to item i of argv
+        if currentArg is "--id" then
+            set idFlag to true
+            set dirFlag to false
+        else if currentArg is "--dir" then
+            set dirFlag to true
+            set idFlag to false
+        else if idFlag then
+            set end of idList to currentArg
+            set idFlag to false
+        else if dirFlag then
+            set end of dirList to currentArg
+            set dirFlag to false
+        end if
+    end repeat
+
+    -- Ensure the lists are of the same length
+    if (count of idList) is not (count of dirList) then
+        error "The number of IDs and directories must be the same."
+    end if
+
+    -- Initialize the list of QEMU arguments
+    set qemuNewArgs to {}
+
+    -- Initialize the directory list
+    set directoryList to {}
+
+    -- Create QEMU arguments for each directory
+    repeat with i from 1 to (count of dirList)
+        set dirPath to item i of dirList
+        set dirId to item i of idList
+        set dirURL to POSIX file dirPath
+        set {fsdevArgStr, deviceArgStr} to createQemuArgsForDir(dirId, dirPath)
+
+        -- add the directory file obj to the list
+        set end of directoryList to dirURL
+        -- append the arguments to the list
+        set end of qemuNewArgs to {fsdevArg:fsdevArgStr, deviceArg:deviceArgStr, dirURL:dirURL}
+    end repeat
+
+    -- Example usage in UTM
+    tell application  "UTM"
+        set vm to virtual machine id vmId
+        set config to configuration of vm
+
+        -- Get the current QEMU additional arguments
+        set qemuAddArgs to qemu additional arguments of config
+
+        -- Add the new arguments to the existing ones
+        repeat with arg in qemuNewArgs
+        -- SKIP: adding file urls to qemu args file urls , since it is not necessary. UTM#6977
+            set end of qemuAddArgs to {argument string:fsdevArg of arg}
+            set end of qemuAddArgs to {argument string:deviceArg of arg}
+        end repeat
+
+        -- Update the configuration with the new arguments list
+        set qemu additional arguments of config to qemuAddArgs
+        update configuration of vm with config
+
+        -- Get the current directory shares in registry
+        set reg to registry of vm
+        -- Add new directory shares to the registry
+        set reg to reg & directoryList
+        -- Update registry of vm with new directory shares
+        update registry of vm with reg
+    end tell
+end run

data/lib/vagrant_utm/scripts/add_qemu_additional_args.applescript

@@ -0,0 +1,43 @@
+---
+-- add_qemu_additional_args.applescript
+-- This script adds qemu arguments to a specified UTM virtual machine.
+-- Usage: osascript add_qemu_additional_args.applescript <VM_UUID> --args <arg1> <arg2> ...
+-- Example: osascript add_qemu_additional_args.applescript A123 --args "-vnc 127.0.0.1:13" "-vnc..."
+
+on run argv
+  set vmId to item 1 of argv # UUID of the VM
+
+  -- Initialize variables
+  set argsList to {}
+  set argsFlag to false
+
+  -- Parse the --args arguments
+  repeat with i from 2 to (count of argv)
+    set currentArg to item i of argv
+    if currentArg is "--args" then
+      set argsFlag to true
+    else if argsFlag then
+      set end of argsList to currentArg
+    end if
+  end repeat
+
+  tell application "UTM"
+    -- Get the VM and its configuration
+    set vm to virtual machine id vmId -- Id is assumed to be valid
+    set config to configuration of vm
+
+    -- Existing arguments
+    set qemuAddArgs to qemu additional arguments of config
+
+    -- Create new arguments from argsList and add them to the existing arguments
+    repeat with arg in argsList
+      set end of qemuAddArgs to {argument string:arg}
+    end repeat
+
+    --- set qemu args with new args list
+    set qemu additional arguments of config to qemuAddArgs
+
+    --- save the configuration (VM must be stopped)
+    update configuration of vm with config
+  end tell
+end run

data/lib/vagrant_utm/scripts/read_shared_folders.js

@@ -0,0 +1,47 @@
+/**
+ * Reads the shared directory IDs from the QEMU additional arguments of a specified VM in UTM.
+ * 
+ * This function uses the UTM application to read the QEMU additional arguments
+ * of a VM identified by the given VM ID and extracts the IDs of shared directories.
+ * 
+ * @param {string} vmIdentifier - The ID of the VM.
+ * @returns {string} A JSON string containing the shared directory IDs or an error message.
+ */
+function run(argv) {
+  // Check if a VM ID is provided
+  if (argv.length === 0) {
+      console.log("Usage: osascript -l JavaScript read_shared_directories.js <vm_id>");
+      return JSON.stringify({ status: false, result: "No VM ID provided." });
+  }
+
+  const vmIdentifier = argv[0];
+  const utm = Application('UTM');
+  utm.includeStandardAdditions = true;
+
+  try {
+      // Attempt to get the VM by ID
+      const vm = utm.virtualMachines.byId(vmIdentifier);
+      // Get the config of the VM
+      const config = vm.configuration();
+      // Get the QEMU additional arguments
+      const qemuArgs = config.qemuAdditionalArguments;
+      
+      // Extract shared directory IDs
+      const sharedDirIds = [];
+      qemuArgs.forEach(arg => {
+          const argStr = arg.argumentString;
+          if (argStr.startsWith("-fsdev")) {
+              const match = argStr.match(/id=([^,]+)/);
+              if (match) {
+                  sharedDirIds.push(match[1]);
+              }
+          }
+      });
+
+      // Return the shared directory IDs
+      return JSON.stringify({ status: true, result: sharedDirIds });
+  } catch (error) {
+      // Return an error message
+      return JSON.stringify({ status: false, result: error.message });
+  }
+}

data/lib/vagrant_utm/scripts/read_shared_folders_args.js

@@ -0,0 +1,53 @@
+/**
+ * Reads the shared folder QEMU arguments for specified IDs from the QEMU additional arguments of a VM in UTM.
+ * 
+ * This function uses the UTM application to read the QEMU additional arguments
+ * of a VM identified by the given VM ID and extracts the arguments for the specified IDs.
+ * 
+ * @param {string} vmIdentifier - The ID of the VM.
+ * @param {string} ids - Comma-separated list of directory IDs.
+ * @returns {string} A JSON string containing the QEMU arguments for the specified IDs or an error message.
+ */
+function run(argv) {
+  // Check if a VM ID and IDs are provided
+  if (argv.length < 2) {
+      console.log("Usage: osascript -l JavaScript read_shared_folders_args.js <vm_id> --ids <dirID>,<dirID>");
+      return JSON.stringify({ status: false, result: "No VM ID or IDs provided." });
+  }
+
+  const vmIdentifier = argv[0];
+  const idsArgIndex = argv.indexOf("--ids");
+  if (idsArgIndex === -1 || idsArgIndex + 1 >= argv.length) {
+      return JSON.stringify({ status: false, result: "No IDs provided." });
+  }
+  const ids = argv[idsArgIndex + 1].split(",");
+
+  const utm = Application('UTM');
+  utm.includeStandardAdditions = true;
+
+  try {
+      // Attempt to get the VM by ID
+      const vm = utm.virtualMachines.byId(vmIdentifier);
+      // Get the config of the VM
+      const config = vm.configuration();
+      // Get the QEMU additional arguments
+      const qemuArgs = config.qemuAdditionalArguments;
+
+      // Extract QEMU arguments for the specified IDs
+      const sharedDirArgs = [];
+      qemuArgs.forEach(arg => {
+          const argStr = arg.argumentString;
+          ids.forEach(id => {
+              if (argStr.includes(`id=${id}`) || argStr.includes(`fsdev=${id}`)) {
+                  sharedDirArgs.push(argStr);
+              }
+          });
+      });
+
+      // Return the QEMU arguments for the specified IDs
+      return JSON.stringify({ status: true, result: sharedDirArgs });
+  } catch (error) {
+      // Return an error message
+      return JSON.stringify({ status: false, result: error.message });
+  }
+}

data/lib/vagrant_utm/scripts/remove_qemu_additional_args.applescript

@@ -0,0 +1,46 @@
+---
+-- remove_qemu_additional_args.applescript
+-- This script removes specified qemu arguments from a specified UTM virtual machine.
+-- Usage: osascript remove_qemu_additional_args.applescript <VM_UUID> --args <arg1> <arg2> ...
+-- Example: osascript remove_qemu_additional_args.applescript A123 --args "-vnc 127.0.0.1:13" "-vnc..."
+
+on run argv
+  set vmId to item 1 of argv -- UUID of the VM
+
+  -- Initialize variables
+  set argsToRemove to {}
+  set argsFlag to false
+
+  -- Parse the --args arguments
+  repeat with i from 2 to (count of argv)
+    set currentArg to item i of argv
+    if currentArg is "--args" then
+      set argsFlag to true
+    else if argsFlag then
+      set end of argsToRemove to currentArg
+    end if
+  end repeat
+
+  tell application "UTM"
+    -- Get the VM and its configuration
+    set vm to virtual machine id vmId -- Id is assumed to be valid
+    set config to configuration of vm
+
+    -- Get the current QEMU additional arguments
+    set qemuAddArgs to qemu additional arguments of config
+
+    -- Initialize a new list for the updated arguments
+    set updatedArgs to {}
+
+    -- Iterate through the current arguments and add all except the ones to remove
+    repeat with arg in qemuAddArgs
+      if arg is not in argsToRemove then
+        set end of updatedArgs to arg
+      end if
+    end repeat
+
+    -- Update the configuration with the new arguments list
+    set qemu additional arguments of config to updatedArgs
+    update configuration of vm with config
+  end tell
+end run

data/lib/vagrant_utm/synced_folder.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module Utm
+    # Default Synced folder implementation for UTM
+    class SyncedFolder < Vagrant.plugin("2", :synced_folder)
+      def usable?(machine, _raise_errors = false) # rubocop:disable Style/OptionalBooleanParameter
+        # These synced folders only work if the provider is UTM
+        return false if machine.provider_name != :utm
+
+        # This only happens with `vagrant package --base`. Sigh.
+        return true unless machine.provider_config
+
+        machine.provider_config.functional_9pfs
+      end
+
+      # This is called before VM Boot to prepare the synced folders.
+      # Add required configs to the VM.
+      def prepare(machine, folders, _opts)
+        share_folders(machine, folders)
+      end
+
+      # This is called after VM Boot to mount the synced folders.
+      # Mount the shared folders inside the VM.
+      def enable(machine, folders, _opts) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/PerceivedComplexity
+        share_folders(machine, folders)
+
+        # sort guestpaths first, so we don't step on ourselves
+        folders = folders.sort_by do |_id, data|
+          if data[:guestpath]
+            data[:guestpath].length
+          else
+            # A long enough path to just do this at the end.
+            10_000
+          end
+        end
+
+        # Go through each folder and mount
+        machine.ui.output(I18n.t("vagrant.actions.vm.share_folders.mounting"))
+        # refresh fstab
+        fstab_folders = [] # rubocop:disable Lint/UselessAssignment
+        folders.each do |id, data|
+          if data[:guestpath]
+            # Guest path specified, so mount the folder to specified point
+            machine.ui.detail(I18n.t("vagrant.actions.vm.share_folders.mounting_entry",
+                                     guestpath: data[:guestpath],
+                                     hostpath: data[:hostpath]))
+
+            # Dup the data so we can pass it to the guest API
+            data = data.dup
+
+            # Calculate the owner and group
+            ssh_info = machine.ssh_info
+            data[:owner] ||= ssh_info[:username]
+            data[:group] ||= ssh_info[:username]
+
+            # Unmount the folder before we mount it
+            machine.guest.capability(
+              :unmount_virtualbox_shared_folder,
+              data[:guestpath], data
+            )
+
+            # Mount the actual folder
+            machine.guest.capability(
+              :mount_virtualbox_shared_folder,
+              os_friendly_id(id), data[:guestpath], data
+            )
+          else
+            # If no guest path is specified, then automounting is disabled
+            machine.ui.detail(I18n.t("vagrant.actions.vm.share_folders.nomount_entry",
+                                     hostpath: data[:hostpath]))
+          end
+        end
+      end
+
+      def disable(machine, folders, _opts)
+        if machine.guest.capability?(:unmount_virtualbox_shared_folder)
+          folders.each_value do |data|
+            machine.guest.capability(
+              :unmount_virtualbox_shared_folder,
+              data[:guestpath], data
+            )
+          end
+        end
+
+        # Remove the shared folders from the VM metadata
+        names = folders.map { |id, _data| os_friendly_id(id) }
+        driver(machine).unshare_folders(names)
+      end
+
+      def cleanup(machine, _opts)
+        driver(machine).clear_shared_folders if machine.id && machine.id != ""
+      end
+
+      protected
+
+      # This is here so that we can stub it for tests
+      def driver(machine)
+        machine.provider.driver
+      end
+
+      def os_friendly_id(id)
+        id.gsub(%r{[\s/\\]}, "_").sub(/^_/, "")
+      end
+
+      # share_folders sets up the shared folder definitions on the
+      # UTM VM.
+      #
+      def share_folders(machine, folders)
+        defs = []
+
+        folders.each do |id, data|
+          hostpath = data[:hostpath]
+          hostpath = Vagrant::Util::Platform.cygwin_windows_path(hostpath) unless data[:hostpath_exact]
+
+          defs << {
+            name: os_friendly_id(id),
+            hostpath: hostpath.to_s,
+            automount: !data[:automount].nil?
+          }
+        end
+
+        driver(machine).share_folders(defs)
+      end
+    end
+  end
+end

data/lib/vagrant_utm/util/unix_mount_helpers.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+# Copied from vagrant/plugins/synced_folder/unix_mount_helpers.rb
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "shellwords"
+require "vagrant/util/retryable"
+
+module VagrantPlugins
+  module SyncedFolder
+    # Contains helper methods for mounting folders on Unix-based systems.
+    module UnixMountHelpers # rubocop:disable Metrics/ModuleLength
+      def self.extended(klass)
+        unless klass.class_variable_defined?(:@@logger)
+          klass.class_variable_set(:@@logger, Log4r::Logger.new(klass.name.downcase)) # rubocop:disable Style/ClassVars
+        end
+        klass.extend Vagrant::Util::Retryable
+      end
+
+      def detect_owner_group_ids(machine, guest_path, mount_options, options) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+        mount_uid = find_mount_options_id("uid", mount_options)
+        mount_gid = find_mount_options_id("gid", mount_options)
+
+        if mount_uid.nil?
+          if options[:owner].to_i.to_s == options[:owner].to_s
+            mount_uid = options[:owner]
+            class_variable_get(:@@logger).debug("Owner user ID (provided): #{mount_uid}")
+          else
+            output = { stdout: String.new, stderr: String.new } # Ensure strings are not frozen
+            uid_command = "id -u #{options[:owner]}"
+            machine.communicate.execute(uid_command,
+                                        error_class: Vagrant::Errors::VirtualBoxMountFailed,
+                                        error_key: :virtualbox_mount_failed,
+                                        command: uid_command,
+                                        output: output[:stderr]) { |type, data| output[type] << data if output[type] }
+            mount_uid = output[:stdout].chomp
+            class_variable_get(:@@logger).debug("Owner user ID (lookup): #{options[:owner]} -> #{mount_uid}")
+          end
+        else
+          machine.ui.warn "Detected mount owner ID within mount options. (uid: #{mount_uid} guestpath: #{guest_path})"
+        end
+
+        if mount_gid.nil?
+          if options[:group].to_i.to_s == options[:group].to_s
+            mount_gid = options[:group]
+            class_variable_get(:@@logger).debug("Owner group ID (provided): #{mount_gid}")
+          else
+            begin
+              { stdout: String.new, stderr: String.new } # Ensure strings are not frozen
+              gid_command = "getent group #{options[:group]}"
+              machine.communicate.execute(gid_command,
+                                          error_class: Vagrant::Errors::VirtualBoxMountFailed,
+                                          error_key: :virtualbox_mount_failed,
+                                          command: gid_command,
+                                          output: output[:stderr]) { |type, data| output[type] << data if output[type] }
+              mount_gid = output[:stdout].split(":").at(2).to_s.chomp
+              class_variable_get(:@@logger).debug("Owner group ID (lookup): #{options[:group]} -> #{mount_gid}")
+            rescue Vagrant::Errors::VirtualBoxMountFailed
+              if options[:owner] == options[:group] # rubocop:disable Metrics/BlockNesting
+                class_variable_get(:@@logger).debug("Failed to locate group `#{options[:group]}`. Group name matches owner. Fetching effective group ID.") # rubocop:disable Layout/LineLength
+                output = { stdout: String.new }
+                result = machine.communicate.execute("id -g #{options[:owner]}",
+                                                     error_check: false) do |type, data|
+                  output[type] << data if output[type] # rubocop:disable Metrics/BlockNesting
+                end
+                mount_gid = output[:stdout].chomp if result.zero? # rubocop:disable Metrics/BlockNesting
+                class_variable_get(:@@logger).debug("Owner group ID (effective): #{mount_gid}")
+              end
+              raise unless mount_gid
+            end
+          end
+        else
+          machine.ui.warn "Detected mount group ID within mount options. (gid: #{mount_gid} guestpath: #{guest_path})"
+        end
+        { gid: mount_gid, uid: mount_uid }
+      end
+
+      def find_mount_options_id(id_name, mount_options) # rubocop:disable Metrics/AbcSize
+        id_line = mount_options.detect { |line| line.include?("#{id_name}=") }
+        if id_line
+          match = id_line.match(/,?#{Regexp.escape(id_name)}=(?<option_id>\d+),?/)
+          found_id = match["option_id"]
+          updated_id_line = [
+            match.pre_match,
+            match.post_match
+          ].find_all { |string| !string.empty? }.join(",")
+          if updated_id_line.empty?
+            mount_options.delete(id_line)
+          else
+            idx = mount_options.index(id_line)
+            mount_options.delete(idx)
+            mount_options.insert(idx, updated_id_line)
+          end
+        end
+        found_id
+      end
+
+      def emit_upstart_notification(machine, guest_path)
+        # Emit an upstart event if we can
+        machine.communicate.sudo <<-NOTIFICATION.gsub(/^ {12}/, "")
+            if test -x /sbin/initctl && command -v /sbin/init && /sbin/init 2>/dev/null --version | grep upstart; then
+              /sbin/initctl emit --no-wait vagrant-mounted MOUNTPOINT=#{guest_path}
+            fi
+        NOTIFICATION
+      end
+
+      def merge_mount_options(base, overrides) # rubocop:disable Metrics/AbcSize
+        base = base.join(",").split(",")
+        overrides = overrides.join(",").split(",")
+        b_kv = Hash[base.map { |item| item.split("=", 2) }]
+        o_kv = Hash[overrides.map { |item| item.split("=", 2) }]
+        merged = {}.tap do |opts|
+          (b_kv.keys + o_kv.keys).uniq.each do |key|
+            opts[key] = o_kv.fetch(key, b_kv[key])
+          end
+        end
+        merged.map do |key, value|
+          [key, value].compact.join("=")
+        end
+      end
+    end
+  end
+end

data/lib/vagrant_utm/version.rb

@@ -4,6 +4,6 @@ module VagrantPlugins
   # Top level module for the Utm provider plugin.
   module Utm
     # Current version of the Utm provider plugin.
-    VERSION = "0.1.1"
+    VERSION = "0.1.3"
   end
 end