vagrant_utm 0.0.1

data/lib/vagrant_utm/provider.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "log4r"
+
+module VagrantPlugins
+  module Utm
+    # Provider that is responsible for managing the virtual machine and exposing it to Vagrant.
+    class Provider < Vagrant.plugin("2", :provider)
+      # The driver for this provider.
+      attr_reader :driver
+
+      def self.installed?
+        Driver::Meta.new
+        true
+      rescue Errors::UtmInvalidVersion,
+             Errors::UtmNotDetected
+        raise if raise_error
+
+        false
+      end
+
+      # Check if the provider is usable.
+      # rubocop:disable Style/OptionalBooleanParameter
+      def self.usable?(raise_error = false)
+        raise Errors::MacOSRequired unless Vagrant::Util::Platform.darwin?
+
+        # Instantiate the driver, which will determine the UTM
+        # version and all that, which checks for UTM being present.
+        Driver::Meta.new
+        true
+      rescue Errors::MacOSRequired,
+             Errors::UtmInvalidVersion,
+             Errors::UtmNotDetected
+        raise if raise_error
+
+        false
+      end
+      # rubocop:enable Style/OptionalBooleanParameter
+
+      # Initialize the provider with given machine.
+      def initialize(machine)
+        super
+        @logger = Log4r::Logger.new("vagrant::provider::utm")
+        @machine = machine
+
+        # This method will load in our driver, so we call it now to
+        # initialize it.
+        machine_id_changed
+      end
+
+      # @see Vagrant::Plugin::V1::Provider#action
+      def action(name)
+        # Attempt to get the action method from the Action class if it
+        # exists, otherwise return nil to show that we don't support the
+        # given action.
+        action_method = "action_#{name}"
+        return Action.send(action_method) if Action.respond_to?(action_method)
+
+        nil
+      end
+
+      # If the machine ID changed, then we need to rebuild our underlying
+      # driver.
+      def machine_id_changed
+        id = @machine.id
+
+        begin
+          @logger.debug("Instantiating the driver for machine ID: #{@machine.id.inspect}")
+          @driver = Driver::Meta.new(id)
+        rescue Driver::Meta::VMNotFound
+          # The virtual machine doesn't exist, so we probably have a stale
+          # ID. Just clear the id out of the machine and reload it.
+          @logger.debug("VM not found! Clearing saved machine ID and reloading.")
+          id = nil
+          retry
+        end
+      end
+
+      # Returns the SSH info for accessing the UTM VM.
+      def ssh_info
+        # If the VM is not running (utm, started) then we can't possibly SSH into it
+        # TODO: We should use the state 'running', rather than 'started'
+        # UTM provider, which does not expose 'running' state. So we use 'started' state
+        return nil if state.id != :started
+
+        # Return what we know
+        # host = IP address of the VM
+        # port = the SSH port
+        # username = vagrant, the default vagrant user
+        # private_key_path = get the private key of the VM (default ~/.vagrant.d/insecure_private_key)
+
+        # Return ssh info for connector to connect to the VM
+        # If VM has shared network adapter in UTM, then we can use the IP address of the VM
+        # If we have multiple network adapters, we need to pick the right one, read_guest_ip returns just first IP
+        # Also, since Vagrant by default adds port forwarding for ssh port 22,
+        # we might aswell use the forwarded ports to connect to the VM using the localhost.
+        {
+          host: "127.0.0.1",
+          port: @driver.ssh_port(@machine.config.ssh.guest_port)
+        }
+      end
+
+      # Return the state of UTM virtual machine by actually
+      # querying utmctl.
+      #
+      # @return [Symbol]
+      def state
+        @logger.info("Getting state of '#{@machine.id}'")
+
+        # Determine the ID of the state here.
+        state_id = nil
+        state_id = :not_created unless @driver.uuid
+        state_id ||= @driver.read_state
+        state_id ||= :unknown
+
+        # Translate into short/long descriptions
+        short = state_id.to_s.gsub("_", " ")
+        long  = I18n.t("vagrant_utm.commands.status.#{state_id}")
+
+        # If we're not created, then specify the special ID flag
+        state_id = Vagrant::MachineState::NOT_CREATED_ID if state_id == :not_created
+
+        # Return the state
+        Vagrant::MachineState.new(state_id, short, long)
+      end
+
+      # TODO: Get UUID of the VM from UTM
+      # Returns a human-friendly string version of this provider which
+      # includes the machine's ID that this provider represents, if it
+      # has one.
+      #
+      # @return [String]
+      def to_s
+        id = @machine.id || "new VM"
+        "UTM (#{id})"
+      end
+    end
+  end
+end

data/lib/vagrant_utm/scripts/add_port_forwards.applescript

@@ -0,0 +1,72 @@
+# Usage: osascript add_port_forwards.applescript UUID  --index 2 "protocol,guestIp,guestPort,hostIp,hostPort" --index 1 "UdPp,100,100,100,100"
+# index is the index of the network interface
+on run argv
+  -- VM id is assumed to be the first argument
+  set vmID to item 1 of argv 
+  -- Initialize an empty list to store port forwarding rules
+  set portForwardRules to {}
+
+  -- Parse the arguments
+  repeat with i from 2 to count of argv by 3
+    set indexArg to item i of argv
+    set indexNumber to item (i + 1) of argv
+    set ruleArg to item (i + 2) of argv
+    
+    -- Index number is assume to point to 'emulated' network interface
+    -- port forwarding does not work with other network interfaces
+    -- even though the UTM API allows it
+    set indexNumber to indexNumber as integer
+
+    -- Port forwarding rules are assumed to be in the format
+    --  "protocol,guestAddress,guestPort,hostAddress,hostPort"
+    set AppleScript's text item delimiters to ","
+
+    -- Split the rule argument into its components
+    set ruleComponents to text items of ruleArg
+    
+    -- Create a port forwarding rule record
+    set portForwardRule to { �
+          indexVal:indexNumber, protocolVal:item 1 of ruleComponents, �
+          guestAddress:item 2 of ruleComponents, guestPort:item 3 of ruleComponents, �
+          hostAddress:item 4 of ruleComponents, hostPort:item 5 of ruleComponents �
+        }
+    
+    -- Add the rule to the list
+    set end of portForwardRules to portForwardRule
+  end repeat
+
+  -- Add port forwarding rules to the corresponding network interfaces
+  tell application "UTM"
+    set vm to virtual machine id vmID
+    set config to configuration of vm
+
+    set networkInterfaces to network interfaces of config
+    repeat with anInterface in networkInterfaces
+      set netIfIndex to index of anInterface
+      repeat with portForwardRule in portForwardRules
+        if (indexVal of portForwardRule) as integer is netIfIndex then
+          -- Existing port forwards
+          set portForwards to port forwards of anInterface
+          
+          -- Create a new port forward configuration
+          set newPortForward to { �
+                protocol:(protocolVal of portForwardRule), �
+                guest address:(guestAddress of portForwardRule), � 
+                guest port:(guestPort of portForwardRule), �
+                host address:(hostAddress of portForwardRule), �
+                host port:(hostPort of portForwardRule) �
+              }
+          
+          -- Add new port forward to the list
+          copy newPortForward to the end of portForwards
+          
+          -- Update the port forwards for the current interface
+          set port forwards of anInterface to portForwards
+        end if
+      end repeat
+    end repeat
+    
+    -- Update the VM configuration
+    update configuration of vm with config
+  end tell
+end run

data/lib/vagrant_utm/scripts/clear_port_forwards.applescript

@@ -0,0 +1,56 @@
+# Usage: osascript clear_port_forwards.applescript <vmID> --index <index> <hostPort> --index <index> <hostPort> ...
+# index is the index of the network interface
+# hostPort is the host port to remove from the port forwards
+on run argv
+  -- VM id is assumed to be the first argument
+  set vmID to item 1 of argv 
+    -- Initialize an empty list to store port forwarding rules to be deleted
+    set portForwardRules to {}
+
+    -- Parse the arguments
+    repeat with i from 2 to count of argv by 3
+        set indexArg to item i of argv
+        set indexNumber to item (i + 1) of argv
+        set hostPortArg to item (i + 2) of argv
+        
+        -- Assumed the index to be 'emulated' network interface
+        set indexNumber to indexNumber as integer
+        
+        -- Create record of index and host port to remove
+        set portForwardRule to {indexVal:indexNumber, hostPort:hostPortArg}
+        
+        -- Add the rule to the list
+        set end of portForwardRules to portForwardRule
+    end repeat
+
+  -- Add port forwarding rules to the corresponding network interfaces
+  tell application "UTM"
+    set vm to virtual machine id vmID
+    set config to configuration of vm
+
+    set networkInterfaces to network interfaces of config
+    repeat with anInterface in networkInterfaces
+      repeat with portForwardRule in portForwardRules
+        if (index of anInterface) is (indexVal of portForwardRule as integer) then
+          -- Existing port forwards
+          set portForwards to port forwards of anInterface
+          
+          -- Find and remove the port forward with the specified host port
+          set updatedPortForwards to {}
+          repeat with aPortForward in portForwards
+            # Dont add the port forward if the host port matches the specified host port
+            if (host port of aPortForward) is not (hostPort of portForwardRule as integer) then
+                set end of updatedPortForwards to aPortForward
+            end if
+          end repeat
+          
+          -- Update the port forwards for the current interface
+          set port forwards of anInterface to updatedPortForwards
+        end if
+      end repeat
+    end repeat
+    
+    -- Update the VM configuration
+    update configuration of vm with config
+  end tell
+end run

data/lib/vagrant_utm/scripts/customize_vm.applescript

@@ -0,0 +1,59 @@
+on run argv
+    tell application "UTM"
+        set vmID to item 1 of argv -- VM id is given as the first argument
+        set vmName to ""
+        set cpuCount to 0
+        set memorySize to 0
+        set vmNotes to ""
+        set directoryShareMode to null
+
+        -- Parse arguments
+        repeat with i from 2 to (count argv)
+            set currentArg to item i of argv
+            if currentArg is "--name" then
+                set vmName to item (i + 1) of argv
+            else if currentArg is "--cpus" then
+                set cpuCount to item (i + 1) of argv
+            else if currentArg is "--memory" then
+                set memorySize to item (i + 1) of argv
+            else if currentArg is "--notes" then
+                set vmNotes to item (i + 1) of argv
+            else if currentArg is "--directory-share-mode" then
+                set directoryShareMode to item (i + 1) of argv
+            end if
+        end repeat
+        
+        -- 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
+        
+        -- Set VM name if provided
+        if vmName is not "" then
+            set name of config to vmName
+        end if
+        
+        -- Set CPU count if provided
+        if cpuCount is not 0 then
+            set cpu cores of config to cpuCount
+        end if
+        
+        -- Set memory size if provided
+        if memorySize is not 0 then
+            set memory of config to memorySize
+        end if
+        
+        -- Set the notes if --notes is provided (existing notes will be overwritten)
+        if vmNotes is not "" then
+            set notes of config to vmNotes
+        end if
+
+        -- Set Directory Sharing mode if provided
+        if directoryShareMode is not null then
+            set directory share mode of config to directoryShareMode -- mode is assumed to be enum value
+        end if
+
+        -- Save the configuration
+        update configuration of vm with config
+ 
+    end tell
+end run

data/lib/vagrant_utm/scripts/downloadVM.sh

@@ -0,0 +1 @@
+open -g "utm://downloadVM?url=$1"

data/lib/vagrant_utm/scripts/list_vm.js

@@ -0,0 +1,32 @@
+/**
+ * Lists all virtual machines managed by UTM and returns their details in JSON format.
+ * 
+ * Mimics the `utmctl list` command.
+ * UUID, Name, and Status
+ * 
+ * @returns {string} A JSON string representing an array of objects, each object containing
+ *                   the UUID, Name, and Status of a virtual machine.
+ */
+function utmctlListVMs() {
+  const utm = Application('UTM');
+  utm.includeStandardAdditions = true;
+
+  // Listing virtual machines
+  const vms = utm.virtualMachines();
+  const vmList = [];
+
+  // Loop through all virtual machines
+  for (const vm of vms) {
+      const vmID = vm.id();
+      const vmName = vm.name();
+      const vmStatus = vm.status();
+      const vmDict = { UUID: vmID, Name: vmName, Status: vmStatus };
+      vmList.push(vmDict);
+  }
+
+  // Convert list to JSON
+  const jsonString = JSON.stringify(vmList);
+  return jsonString;
+}
+
+utmctlListVMs();

data/lib/vagrant_utm/scripts/open_with_utm.js

@@ -0,0 +1,30 @@
+/**
+ * Opens a specified UTM file.
+ * 
+ * This function uses the UTM application to open a UTM file located at the given file path.
+ * It mimics the action of opening a Open with UTM.
+ * 
+ * @param {string} filePath - The file path of the UTM file to be opened.
+ * @returns {string} A JSON string indicating the success or failure of the operation.
+ */
+function run(argv) {
+  // Check if a file path is provided
+  if (argv.length === 0) {
+      console.log("Usage: osascript -l JavaScript open_with_utm.js <path_to_utm_file>");
+      return JSON.stringify({ status: "error", message: "No file path provided." });
+  }
+
+  const filePath = argv[0];
+  const utm = Application('UTM');
+  utm.includeStandardAdditions = true;
+
+  try {
+      // Attempt to open the UTM file
+      utm.open(Path(filePath));
+      // Return a success message
+      return JSON.stringify({ status: "success", message: "UTM file opened successfully." });
+  } catch (error) {
+      // Return an error message if the operation fails
+      return JSON.stringify({ status: "error", message: error.toString() });
+  }
+}

data/lib/vagrant_utm/scripts/read_forwarded_ports.applescript

@@ -0,0 +1,27 @@
+# Usage: osascript read_port_forwards.applescript <vmID>
+# vmID is the id of the virtual machine
+# This script reads the port forwards of the 'emulated' network interface
+# 'Forwarding(nicIndex)(ruleIndex)="protocol,guestAddress,guestPort,hostAddress,hostPort"'
+on run argv
+  set vmID to item 1 of argv
+    tell application "UTM"
+        set vm to virtual machine id vmID
+        set config to configuration of vm
+
+        set networkInterfaces to network interfaces of config
+        repeat with anInterface in networkInterfaces
+            if (mode of anInterface as string) is "emulated" then
+                set portForwards to port forwards of anInterface
+                set i to -1
+                repeat with aPortForward in portForwards
+                    set i to i + 1
+                    # Log the port forward details Virtualbox style 
+                    # 'Forwarding(nicIndex)(ruleIndex)="protocol,guestAddress,guestPort,hostAddress,hostPort"'
+                    log "Forwarding(" & index of anInterface & ")(" & i & ")=\"" & protocol of aPortForward & "," �
+                        & guest address of aPortForward & "," & guest port of aPortForward & "," �
+                        & host address of aPortForward & "," & host port of aPortForward & "\""
+                end repeat
+            end if
+        end repeat
+    end tell
+end run

data/lib/vagrant_utm/scripts/read_guest_ip.applescript

@@ -0,0 +1,9 @@
+on run argv
+  set vmID to item 1 of argv
+  tell application "UTM"
+      set vm to virtual machine id vmID
+      --- get IP address (QEMU Guest Agent must be installed) of first interface
+      get item 1 of (query ip of vm) -- Result: "192.168.64.9"
+  end tell
+end run
+

data/lib/vagrant_utm/scripts/read_network_interfaces.applescript

@@ -0,0 +1,12 @@
+on run argv
+  set vmID to item 1 of argv
+    tell application "UTM"
+        set vm to virtual machine id vmID
+        set config to configuration of vm
+        set networkInterfaces to network interfaces of config
+        repeat with anInterface in networkInterfaces
+            # if you start log with variable you'll get "," at the end of the log if '&' is used to concatenate
+            log "nic" & index of anInterface & "," & mode of anInterface 
+        end repeat
+    end tell
+end run

data/lib/vagrant_utm/util/compile_forwarded_ports.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant/util/scoped_hash_override"
+
+module VagrantPlugins
+  module Utm
+    module Util
+      # This module contains the code to compile the forwarded ports from config.
+      module CompileForwardedPorts
+        include Vagrant::Util::ScopedHashOverride
+
+        # This method compiles the forwarded ports into {ForwardedPort}
+        # models.
+        def compile_forwarded_ports(config) # rubocop:disable Metrics/AbcSize
+          mappings = {}
+
+          config.vm.networks.each do |type, options|
+            next unless type == :forwarded_port
+
+            guest_port = options[:guest]
+            host_port  = options[:host]
+            host_ip    = options[:host_ip]
+            protocol   = options[:protocol] || "tcp"
+            options    = scoped_hash_override(options, :utm)
+            id         = options[:id]
+
+            # If the forwarded port was marked as disabled, ignore.
+            next if options[:disabled]
+
+            key = "#{host_ip}#{protocol}#{host_port}"
+            mappings[key] =
+              Model::ForwardedPort.new(id, host_port, guest_port, options)
+          end
+
+          mappings.values
+        end
+      end
+    end
+  end
+end

data/lib/vagrant_utm/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  # Top level module for the Utm provider plugin.
+  module Utm
+    # Current version of the Utm provider plugin.
+    VERSION = "0.0.1"
+  end
+end

data/lib/vagrant_utm.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "vagrant_utm/plugin"
+
+module VagrantPlugins
+  # Top level module for the UTM provider plugin.
+  module Utm
+    lib_path = Pathname.new(File.expand_path("vagrant_utm", __dir__))
+    autoload :Action, lib_path.join("action")
+    autoload :Errors, lib_path.join("errors")
+
+    # Drop some autoloads in here to optimize the performance of loading
+    # our drivers only when they are needed.
+    module Driver
+      lib_path = Pathname.new(File.expand_path("vagrant_utm/driver", __dir__))
+      autoload :Meta, lib_path.join("meta")
+      autoload :Version_4_5, lib_path.join("version_4_5") # rubocop:disable Naming/VariableNumber
+    end
+
+    # Drop some autoloads for the model classes
+    module Model
+      lib_path = Pathname.new(File.expand_path("vagrant_utm/model", __dir__))
+      autoload :ForwardedPort, lib_path.join("forwarded_port")
+    end
+
+    # Drop some autoloads for the util classes
+    module Util
+      lib_path = Pathname.new(File.expand_path("vagrant_utm/util", __dir__))
+      autoload :CompileForwardedPorts, lib_path.join("compile_forwarded_ports")
+    end
+
+    # This returns the path to the source of this plugin.
+    #
+    # @return [Pathname]
+    def self.source_root
+      @source_root ||= Pathname.new(File.expand_path("..", __dir__))
+    end
+  end
+end