autosparkle 0.0.8 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d68b72cb179b558388027771604619562da6a0293a8901b3aadf9c39fbd39df7
-  data.tar.gz: eaa1e667baba2cd385a63de1d5102ca950b37ecc154b5c8256e6087947d8e973
+  metadata.gz: 53e0dbaf4795bf4f24ea473048c8d3cfdf661628daa9af1a5b46b97bb4b89efa
+  data.tar.gz: 7c01f30d5d9c9363ef949327eae99728228aa9b4156f3f85144681aab64701cc
 SHA512:
-  metadata.gz: 787e99f1fd204d1a9234d22109fc92a2572d09381c8277ffd83e85423ee9fbc286547c700e449876ac6ea3a2b7bf4912901856a5ba4fbd5875e9431ff2e3c540
-  data.tar.gz: 23c2358c76555744a099b67441e032b422f6e5a068f62edda8fae42b74531296e053fe4302bc883ccfa3770911e038238054654d23fbfab7c09482d2aeb4b73c
+  metadata.gz: 65ed38e0821f79d58fa8bf9baf5124ef986d62b5534e27b87d3e0db9ac03356469cb1b1f41f4193dc9fac42ba6d8d5a1f8f1fe64ac266fe71cda51bb8129f0bc
+  data.tar.gz: 6d756b2742e25f5b643f019b628e28f809af2e0b757fdcfb20f432645c27be42f1465af40795ba38d424b618f6eb4a65476a4a59472a2819055ff96918a8bf84

data/README.md

@@ -1,4 +1,6 @@
 # autosparkle
+![GitHub Release](https://img.shields.io/github/v/release/hadiidbouk/autosparkle?style=flat&label=version)
+![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/hadiidbouk/autosparkle/ci.yml)
 
 ![autosparkle main image](resources/readme-main-image.jpg)
 
@@ -59,13 +61,50 @@ autosparkle is a Ruby command line tool that automates the delivery of your macO
    ```bash
    git clone https://github.com/hadiidbouk/autosparkle.git
    ```
-2. Call the `autosparkle.rb` script from the repository, you need to specify your Xcode project path and your environment file. Here's how you can do it:
-    ```bash
-    ruby autosparkle.rb --project-path <<YOUR XCODE PROJECT>> --env <<YOUR ENV NAME>>
-    ```
+2. Execute the Ruby script `autosparkle.rb`, check the [Usage](#usage) section below.
+
+## Usage
+
+There are two ways to utilize autosparkle. The first option is to automate the entire process by using the `automate` command. Alternatively, you can select any of the following commands (`export`, `package`, `distribute`) and build your own solution around them.
+
+
+All of these commands require you to provide the environment file or its name. If you use the `automate` command or the `export` command, which require a project/workspace path, you can simply pass the environment name to the `--env` option. autosparkle will then search for a file named `.env.autosparkle.<<YOUR_ENV_NAME>>` in your project directory (where your Xcode project/workspace is located). For example, if you pass `--env local`, autosparkle will search for `.env.autosparkle.local`.
+
+It is **recommended** to use the `automate` command for several reasons:
+
+1. It automatically handles the app versioning, ensuring consistency between the Info.plist and the `appcast.xml`.
+
+2. The custom keychain is created once for all the signing steps.
+
+3. All the generated files are conveniently located in one place at `~/Library/Developer/autosparkle/build`. When using the commands separately, each command will override any existing files in the build directory.
+
 
-    You can also pass your workspace path using `--workspace-path` and specify the environment path using `--env-file`.
 
+You can explore the functionality of each command by using the `--help` flag. For instance: 
+```bash 
+autosparkle distribute --help
+```
+
+Output:
+```bash
+distribute
+
+  Usage: autosparkle distribute [options]
+
+  Distribute your package to the specified storage and update the appcast.xml file
+
+  Options:
+    --dmg-path PATH      Path of the DMG file to be distributed
+    --app-display-name NAME Name of the app inside the DMG without the .app extension
+    --marketing-version VERSION Marketing version of the app
+    --current-project-version VERSION Current project version of the app
+    --minimum-macos-version VERSION Minimum macOS version required to run the app, defaults to 14.0
+```
+
+
+> **Note:**
+>
+> When using the **distribute** command, autosparkle will automatically calculate the new marketing version and the current project version from the uploaded appcast file (if it exists). If you want to override these values, make sure to pass them using the `--marketing-version` and `--current-project-version` options. Additionally, make sure to set them in your app's Info.plist before exporting the app.
 
 ## Environment
 autosparkle utilizes the [dotenv](https://github.com/bkeepers/dotenv) gem to manage environment variables.
@@ -89,7 +128,7 @@ Below are the list of environment variables used by autosparkle:
 | APP_SPECIFIC_PASSWORD | The App specific password that will be used in the notarize step | Yes | |
 | DEVELOPER_ID_APPLICATION_BASE64 | The Developer ID Application base64 certificate | Yes | |
 | DEVELOPER_ID_APPLICATION_PASSWORD | The Developer ID Application base64 certificate password | Yes | |
-| DMG_BACKGROUND_IMAGE | The DMG background image path that should exist in the project folder | Yes | |
+| DMG_BACKGROUND_IMAGE | The path to the DMG background image. Make sure to use an image with the same width and height as the window to ensure a proper fit. | No | [View it here](lib/autosparkle/resources/default-dmg-background.png) |
 | DMG_WINDOW_WIDTH | The DMG "Drag to Applications" window width | Yes | |
 | DMG_WINDOW_HEIGHT | The DMG "Drag to Applications" window height | Yes | |
 | DMG_ICON_SIZE | The icon size of the app and the Applications folder in the window | Yes | |

data/lib/autosparkle/environment/environment.rb

@@ -7,6 +7,13 @@ require_relative '../helpers/puts_helpers'
 require_relative '../storages/aws_s3_storage'
 require_relative 'variables/default_environment_variables'
 
+module Command
+  EXPORT = 0
+  PACKAGE = 1
+  DISTRIBUTE = 2
+  AUTOMATE = 3
+end
+
 # Environment module to load the environment variables
 # It contains the app state
 module Env
@@ -17,27 +24,69 @@ module Env
   class << self
     attr_accessor :variables, :storage, :verbose_enabled
 
-    def initialize(options)
-      project_path = options[:project_path]
-      workspace_path = options[:workspace_path]
-      project_directory_path = File.dirname(workspace_path || project_path)
+    def initialize(options, command)
+      project_path = options.project_path
+      workspace_path = options.workspace_path
 
-      load_environment(project_directory_path, options)
+      project_directory_path = File.dirname(workspace_path || project_path) if workspace_path || project_path
+      ENV['PROJECT_DIRECTORY_PATH'] = project_directory_path
 
-      @variables = DefaultEnvironmentVariables.new(project_directory_path)
-      @storage = retrieve_storage
+      load_environment(project_directory_path, options.env)
 
-      retrieve_variables_from_xcode(project_path, workspace_path)
-      set_up_app_versions(project_path, workspace_path)
+      @variables = DefaultEnvironmentVariables.new
 
-      puts_if_verbose "Running the script with the #{options[:env]} environment...\n"
+      case command
+      when Command::EXPORT
+        initialize_export(options)
+      when Command::PACKAGE
+        initialize_package(options)
+      when Command::DISTRIBUTE
+        initialize_distribute(options)
+      when Command::AUTOMATE
+        initialize_automate(options)
+      end
+
+      puts_if_verbose "Running the script with the #{options.env} environment...\n"
     end
   end
 
-  def self.load_environment(project_directory_path, options)
-    env_file_path = options[:env_file] || File.join(project_directory_path, ".env.autosparkle.#{options[:env]}")
-    raise "#{env_file_path} does not exist." unless File.exist?(env_file_path)
+  def self.initialize_export(options)
+    retrieve_variables_from_xcode(options.project_path, options.workspace_path)
+  end
+
+  def self.initialize_package(options)
+    ENV['APP_DISPLAY_NAME'] = options.app_display_name
+  end
+
+  def self.initialize_distribute(options)
+    ENV['APP_DISPLAY_NAME'] = options.app_display_name
+    ENV['MINIMUM_MACOS_VERSION'] = options.minimum_macos_version
+
+    @storage = retrieve_storage
+    retreive_versions_variables_form_appcast(options)
+  end
+
+  def self.initialize_automate(options)
+    retrieve_variables_from_xcode(options.project_path, options.workspace_path)
+
+    @storage = retrieve_storage
+    retreive_versions_variables_form_appcast(options)
+  end
+
+  def self.load_environment(project_directory_path, env)
+    env_is_file = File.file?(env)
+    if !project_directory_path && !env_is_file
+      raise 'Cannot find the project directory path to load the environment variables'
+    end
+
+    env_file_path = if env_is_file
+                      env
+                    else
+                      File.join(project_directory_path, ".env.autosparkle.#{env}")
+                    end
 
+    ENV['ENV_FILE_PATH'] = env_file_path
+    puts_if_verbose "Loading the environment variables from #{env_file_path}..."
     Dotenv.load(env_file_path)
   end
 
@@ -61,13 +110,10 @@ module Env
     ENV['APP_DISPLAY_NAME'] = Xcodeproj.get_app_display_name(project_path, workspace_path)
   end
 
-  def self.set_up_app_versions(project_path, workspace_path)
+  def self.retreive_versions_variables_form_appcast(options)
     marketing_version, current_project_version = AppcastXML.retreive_versions(@storage.deployed_appcast_xml)
 
-    ENV['MARKETING_VERSION'] = marketing_version
-    ENV['CURRENT_PROJECT_VERSION'] = current_project_version
-
-    puts_if_verbose 'Updating the project versions from the environment variables...'
-    Xcodeproj.update_project_version(project_path, workspace_path)
+    ENV['MARKETING_VERSION'] = options.marketing_version || marketing_version
+    ENV['CURRENT_PROJECT_VERSION'] = options.current_project_version || current_project_version
   end
 end

data/lib/autosparkle/environment/variables/default_environment_variables.rb

@@ -6,8 +6,9 @@ require_relative 'base_environment_variables'
 
 # A class to load the default environment variables
 class DefaultEnvironmentVariables < BaseEnvironmentVariables
-  def initialize(project_directory_path)
+  def initialize
     super({
+      env_file_path: 'ENV_FILE_PATH',
       project_directory_path: 'PROJECT_DIRECTORY_PATH',
       scheme: 'SCHEME',
       configuration: 'CONFIGURATION',
@@ -29,7 +30,5 @@ class DefaultEnvironmentVariables < BaseEnvironmentVariables
       dmg_window_width: 'DMG_WINDOW_WIDTH',
       dmg_window_height: 'DMG_WINDOW_HEIGHT'
     })
-
-    ENV['PROJECT_DIRECTORY_PATH'] = project_directory_path
   end
 end

data/lib/autosparkle/helpers/constants.rb

@@ -4,4 +4,7 @@
 module Constants
   NOTARIZE_KEYCHAIN_PROFILE = 'autosparkle.keychain.notarize.profile'
   AUTOSPARKLE_BUILD_DIRECTORY_PATH = '~/Library/Developer/autosparkle/build'
+  KEYCHAIN_NAME = 'temporary.autosparkle.keychain'
+  KEYCHAIN_PATH = "~/Library/Keychains/#{KEYCHAIN_NAME}-db"
+  KEYCHAIN_PASSWORD = 'autosparkle'
 end

data/lib/autosparkle/helpers/dmg_helpers.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'fileutils'
+require 'xcodeproj'
 require_relative 'build_directory_helpers'
 require_relative 'puts_helpers'
 require_relative '../environment/environment'
@@ -9,9 +10,10 @@ require_relative '../environment/environment'
 module DMG
   def self.create(app_path)
     volume_name = Env.variables.app_display_name
-    background_image_path = "#{Env.variables.project_directory_path}/#{Env.variables.dmg_background_image}"
 
-    dmg_path = create_blank_dmg(app_path, background_image_path, volume_name)
+    background_image_path = dmg_background_image_path
+    volume_size = calculate_volume_size(app_path, background_image_path)
+    dmg_path = create_blank_dmg(volume_size, volume_name)
     mount(dmg_path, volume_name)
     copy_app_and_set_symbolic_link(app_path, volume_name)
     copy_background_image(background_image_path, volume_name)
@@ -20,16 +22,32 @@ module DMG
     create_read_only_dmg(dmg_path)
   end
 
-  def self.create_blank_dmg(app_path, background_image_path, volume_name)
+  def self.dmg_background_image_path
+    background_image_path = Env.variables.dmg_background_image
+    final_background_image_path = if background_image_path.start_with?('~')
+                                    File.expand_path(background_image_path)
+                                  elsif background_image_path.start_with?('/')
+                                    background_image_path
+                                  else
+                                    File.expand_path(background_image_path, Env.variables.env_file_path)
+                                  end
+
+    raise 'DMG background image not found' unless !background_image_path || File.exist?(final_background_image_path)
+
+    default_dmg_background_path = File.join(File.dirname(__dir__), 'resources', 'default-dmg-background.png')
+    final_background_image_path ||= default_dmg_background_path
+    final_background_image_path
+  end
+
+  def self.create_blank_dmg(volume_size, volume_name)
     puts_if_verbose 'Creating a blank DMG...'
-    volume_size = volume_size(app_path, background_image_path)
     uuid = `uuidgen`.strip
     dmg_path = BuildDirectory.new_path("#{Env.variables.app_display_name}-#{uuid}.dmg")
     execute_command("hdiutil create -size #{volume_size}m -fs HFS+ -volname '#{volume_name}' -ov '#{dmg_path}'")
     dmg_path
   end
 
-  def self.volume_size(app_path, background_image_path)
+  def self.calculate_volume_size(app_path, background_image_path)
     app_size_kb = `du -sk "#{app_path}"`.split("\t").first.to_i
     background_size_kb = File.size(background_image_path) / 1024
     buffer_size_kb = 20 * 1024
@@ -51,7 +69,10 @@ module DMG
   def self.copy_background_image(background_image_path, volume_name)
     puts_if_verbose 'Copying the background image to the DMG...'
     FileUtils.mkdir_p("/Volumes/#{volume_name}/.background")
-    FileUtils.cp(background_image_path, "/Volumes/#{volume_name}/.background/")
+
+    background_image_extension = File.extname(background_image_path)
+    FileUtils.cp(background_image_path,
+                 "/Volumes/#{volume_name}/.background/dmg-background#{background_image_extension}")
   end
 
   def self.customize_dmg_appearence(volume_name)
@@ -78,7 +99,7 @@ module DMG
             set the bounds of container window to {0, 0, #{window_width}, #{window_height}}
             set arrangement of icon view options of container window to not arranged
             set icon size of icon view options of container window to #{Env.variables.dmg_icon_size}
-            set background picture of icon view options of container window to file ".background:#{Env.variables.dmg_background_image}"
+            set background picture of icon view options of container window to file ".background:dmg-background.png"
             set position of item "#{Env.variables.app_display_name}.app" of container window to {#{app_x_position}, #{item_y_position}}
             set position of item "Applications" of container window to {#{applications_x_position}, #{item_y_position}}
           close

data/lib/autosparkle/helpers/keychain_helpers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'securerandom'
 require 'open3'
 require 'base64'
@@ -12,36 +14,31 @@ require_relative 'puts_helpers'
 # The temporary keychain will be deleted after the block has been executed.
 #
 def with_temporary_keychain
-  keychain_name = "temporary.autosparkle.keychain-#{SecureRandom.uuid}"
-  keychain_path = "~/Library/Keychains/#{keychain_name}-db"
-  password = SecureRandom.hex(16)
-
   original_keychain_list = `security list-keychains`.strip.split("\n").map(&:strip)
   default_keychain = execute_command('security default-keychain')
   default_keychain_path = default_keychain.gsub(/"(.*)"/, '\1').strip
 
-  delete_temporary_keychain_if_needed(keychain_path)
+  delete_temporary_keychain_if_needed
 
   begin
     # Create a temporary keychain
-    create_temporary_keychain(keychain_path, password, original_keychain_list)
-    import_certificates_in_temporary_keychain(keychain_path)
+    create_temporary_keychain(original_keychain_list)
+    import_certificates_in_temporary_keychain
     execute_command("security set-key-partition-list -S apple-tool:,apple:,codesign: \\
-                  -s -k \"#{password}\" #{keychain_path}")
+                  -s -k \"#{Constants::KEYCHAIN_PASSWORD}\" #{Constants::KEYCHAIN_PATH}")
 
     # Fetch the certificate names and team ids from the temporary keychain
-    application_cert_name, application_team_id = fetch_application_certificate_info(keychain_path)
-    store_notarization_credentials(keychain_path, application_team_id)
+    application_cert_name, application_team_id = fetch_application_certificate_info
+    store_notarization_credentials(application_team_id)
 
     keychain_info = {
-      keychain_path: keychain_path,
       application_cert_name: application_cert_name,
       application_team_id: application_team_id
     }
     yield(keychain_info) if block_given?
   ensure
     puts_if_verbose 'Ensuring cleanup of temporary keychain...'
-    delete_temporary_keychain_if_needed(keychain_path)
+    delete_temporary_keychain_if_needed
 
     # Reset the keychain to the default
     execute_command("security list-keychains -s #{original_keychain_list.join(' ')}")
@@ -51,23 +48,23 @@ end
 
 private
 
-def create_temporary_keychain(keychain_path, password, original_keychain_list)
-  execute_command("security create-keychain -p \"#{password}\" #{keychain_path}")
-  execute_command("security unlock-keychain -p \"#{password}\" #{keychain_path}")
-  execute_command("security list-keychains -d user -s #{(original_keychain_list + [keychain_path]).join(' ')}")
-  execute_command("security default-keychain -s #{keychain_path}")
+def create_temporary_keychain(original_keychain_list)
+  execute_command("security create-keychain -p \"#{Constants::KEYCHAIN_PASSWORD}\" #{Constants::KEYCHAIN_PATH}")
+  execute_command("security unlock-keychain -p \"#{Constants::KEYCHAIN_PASSWORD}\" #{Constants::KEYCHAIN_PATH}")
+  execute_command("security list-keychains -d user -s #{(original_keychain_list + [Constants::KEYCHAIN_PATH]).join(' ')}")
+  execute_command("security default-keychain -s #{Constants::KEYCHAIN_PATH}")
 end
 
-def store_notarization_credentials(keychain_path, application_team_id)
+def store_notarization_credentials(application_team_id)
   command = "xcrun notarytool store-credentials #{Constants::NOTARIZE_KEYCHAIN_PROFILE} \\
-						--keychain #{keychain_path} \\
+						--keychain #{Constants::KEYCHAIN_PATH} \\
 						--apple-id #{Env.variables.apple_id} \\
 						--team-id #{application_team_id} \\
 						--password #{Env.variables.app_specific_password}"
   execute_command(command)
 end
 
-def import_certificates_in_temporary_keychain(keychain_path)
+def import_certificates_in_temporary_keychain
   developer_id_application_p12 = Base64.decode64(Env.variables.developer_id_application_base64 || '')
 
   # Create temporary files for the .p12 certificates
@@ -78,12 +75,11 @@ def import_certificates_in_temporary_keychain(keychain_path)
   application_cert_file.close
 
   # Import the certificates into the temporary keychain
-  import_file_to_keychain(keychain_path, application_cert_file.path,
-                          Env.variables.developer_id_application_password)
+  import_file_to_keychain(application_cert_file.path, Env.variables.developer_id_application_password)
 end
 
-def import_file_to_keychain(keychain_path, file_path, password)
-  command = "security import #{file_path} -k #{keychain_path} -P #{password}"
+def import_file_to_keychain(file_path, password)
+  command = "security import #{file_path} -k #{Constants::KEYCHAIN_PATH} -P #{password}"
   command += ' -T /usr/bin/codesign'
   command += ' -T /usr/bin/security'
   command += ' -T /usr/bin/productbuild'
@@ -91,17 +87,21 @@ def import_file_to_keychain(keychain_path, file_path, password)
   execute_command(command)
 end
 
-def fetch_certificate_info(keychain_path, certificate_type)
-  command = "security find-certificate -c \"#{certificate_type}\" #{keychain_path} | grep \"labl\" | sed -E 's/^.*\"labl\"<blob>=\"(.*)\".*/\\1/'"
+def fetch_certificate_info(certificate_type)
+  command = "security find-certificate -c \"#{certificate_type}\" #{Constants::KEYCHAIN_PATH}"
+  command += " | grep \"labl\" | sed -E 's/^.*\"labl\"<blob>=\"(.*)\".*/\\1/'"
   name = `#{command}`.strip
   team_id = name[/\(([^)]+)\)$/, 1]
   [name, team_id]
 end
 
-def fetch_application_certificate_info(keychain_path)
-  fetch_certificate_info(keychain_path, 'Developer ID Application')
+def fetch_application_certificate_info
+  fetch_certificate_info('Developer ID Application')
 end
 
-def delete_temporary_keychain_if_needed(keychain_path)
-  execute_command("security delete-keychain #{keychain_path}") if File.exist?(File.expand_path(keychain_path.to_s))
+def delete_temporary_keychain_if_needed
+  return unless File.exist?(File.expand_path(Constants::KEYCHAIN_PATH.to_s))
+
+  execute_command("security delete-keychain #{Constants::KEYCHAIN_PATH}")
+  execute_command("rm -rf #{Constants::KEYCHAIN_PATH}")
 end

data/lib/autosparkle/helpers/xcodeproj_helpers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'colorize'
 require 'xcodeproj'
 require 'plist'
@@ -54,7 +56,7 @@ module Xcodeproj
       end
     end
 
-    raise "Target not found for scheme #{Env.variables.scheme_name}".red unless target
+    raise "Target not found for scheme #{Env.variables.scheme}".red unless target
 
     [project, target]
   end

data/lib/autosparkle/main.rb

@@ -1,5 +1,8 @@
-require 'optparse'
-require 'securerandom'
+# frozen_string_literal: true
+
+require 'commander/import'
+require 'fileutils'
+require_relative 'metadata'
 require_relative 'packaging'
 require_relative 'distribution'
 require_relative 'helpers/build_directory_helpers'
@@ -7,67 +10,153 @@ require_relative 'helpers/commands_helpers'
 require_relative 'helpers/keychain_helpers'
 require_relative 'helpers/xcodeproj_helpers'
 require_relative 'helpers/puts_helpers'
+require_relative 'helpers/dmg_helpers'
 require_relative 'environment/environment'
 
-def extract_options
-  options = {}
+program :name, AutoSparkle::NAME
+program :version, AutoSparkle::VERSION
+program :description, AutoSparkle::DESCRIPTION
+program :help_formatter, :compact
 
-  OptionParser.new do |opts|
-    opts.banner = 'Usage: automate-sparkle.rb [options]'
+default_command :help
+global_option('--env ENVIRONMENT', String, 'Environment to load (aka. local, production) or a path to the env file')
+global_option('--verbose', 'Enable verbose mode') { Env.verbose_enabled = true }
 
-    opts.on('--project-path PATH', 'Path to the Xcode project') do |path|
-      options[:project_path] = path
-    end
+command :export do |c|
+  c.syntax = "#{AutoSparkle::NAME} export [options]"
+  c.description = 'Archive and export the macOS app'
+  c.option('--project-path PATH', String, 'Path to the Xcode project')
+  c.option('--workspace-path PATH', String, 'Path to the Xcode workspace')
+  c.option('--skip-sparkle-steps', 'Skip the sparkle config check and signing the framework')
+  c.option('--output-dir PATH', String, 'Path to the output directory')
+  c.action do |_args, options|
+    options.default \
+      output_dir: Dir.pwd
 
-    opts.on('--workspace-path PATH', 'Path to the Xcode workspace') do |path|
-      options[:workspace_path] = path
-    end
+    raise 'env name/path is required.' unless options.env
+    raise 'Xcode Project/Workspace file is required.' unless options.workspace_path || options.project_path
+    raise 'Environment/Environment file is required.' unless options.env || options.env_file
 
-    env_description = 'Environment to load (aka. local, production)'
-    env_description += ' it will look inside the Xcode project/workspace path'
-    env_description += ' for a file named `.autosparkle.env.<environment>`'
+    BuildDirectory.create_build_directory
+    Env.initialize(options, Command::EXPORT)
 
-    opts.on('--env ENVIRONMENT', env_description) do |env|
-      options[:env] = env
+    unless options.skip_sparkle_steps
+      Xcodeproj.check_sparkle_configuration_existence(
+        options.project_path,
+        options.workspace_path
+      )
     end
 
-    opts.on('--env-file PATH', 'Path to the environment file') do |path|
-      options[:env_file] = path
-    end
+    with_temporary_keychain do |keychain_info|
+      archive_and_sign_hash = {
+        application_cert_name: keychain_info[:application_cert_name],
+        application_team_id: keychain_info[:application_team_id],
+        project_path: options.project_path,
+        workspace_path: options.workspace_path,
+        output_dir: options.output_dir,
+        skip_sparkle_steps: options.skip_sparkle_steps
+      }
 
-    opts.on('-v', 'Enable verbose mode') do |verbose|
-      Env.verbose_enabled = verbose
-    end
-  end.parse!
+      exported_app_path = Packaging.archive_and_sign(archive_and_sign_hash)
 
-  # Check if both project path and environment are specified
-  unless (options[:workspace_path] || options[:project_path]) && (options[:env] || options[:env_file])
-    raise 'Xcode Project/Workspace path and Environment/Environment file are required.'
+      puts "Exported the app to #{exported_app_path}"
+    end
   end
+end
 
-  options
+command :package do |c|
+  c.syntax = "#{AutoSparkle::NAME} package [options]"
+  c.description = 'Package the macOS app into a DMG file'
+  c.option('--app-path PATH', String, 'Path to the exported app')
+  c.option('--output-dir PATH', String, 'Path to the output directory')
+  c.action do |_args, options|
+    options.default \
+      output_dir: Dir.pwd
+
+    raise 'env name/path is required.' unless options.env
+    raise 'App path is required.' unless options.app_path
+
+    # Add the app-path file name without the extension to options
+    app_path = File.expand_path(options.app_path)
+    options.app_display_name = File.basename(app_path, '.*')
+
+    BuildDirectory.create_build_directory
+    Env.initialize(options, Command::PACKAGE)
+
+    with_temporary_keychain do |keychain_info|
+      dmg_path = Packaging.create_and_sign_dmg(
+        app_path,
+        keychain_info[:application_cert_name],
+        options.output_dir
+      )
+
+      puts "Packaged the app into a DMG file at #{dmg_path}"
+    end
+  end
 end
 
-options = extract_options
-Env.initialize(options)
-
-Xcodeproj.check_sparkle_configuration_existence(options[:project_path], options[:workspace_path])
-
-BuildDirectory.create_build_directory
-
-puts "Automating the delivery of #{Env.variables.app_display_name} version #{Env.variables.marketing_version} (#{Env.variables.current_project_version})..."
-dmg_path = nil
-with_temporary_keychain do |keychain_info|
-  exported_app_path = Packaging.archive_and_sign(
-    keychain_info[:application_cert_name],
-    keychain_info[:application_team_id],
-    options
-  )
-  dmg_path = Packaging.create_and_sign_dmg(
-    exported_app_path,
-    keychain_info[:application_cert_name],
-    keychain_info[:keychain_path]
-  )
+command :distribute do |c|
+  c.syntax = "#{AutoSparkle::NAME} distribute [options]"
+  c.description = 'Distribute your package to the specified storage and update the appcast.xml file'
+  c.option('--dmg-path PATH', String, 'Path of the DMG file to be distributed')
+  c.option('--app-display-name NAME', String, 'Name of the app inside the DMG without the .app extension')
+  c.option('--marketing-version VERSION', String, 'Marketing version of the app')
+  c.option('--current-project-version VERSION', String, 'Current project version of the app')
+  c.option('--minimum-macos-version VERSION', String, 'Minimum macOS version required to run the app, defaults to 14.0')
+  c.action do |_args, options|
+    raise 'env name/path is required.' unless options.env
+    raise 'dmg path is required, please pass it using --dmg-path' unless options.dmg_path
+    raise 'No dmg file found at the specified path' unless File.exist?(options.dmg_path)
+    raise 'App display name is required.' unless options.app_display_name
+
+    options.default \
+      minimum_macos_version: '14.0'
+
+    BuildDirectory.create_build_directory
+    Env.initialize(options, Command::DISTRIBUTE)
+
+    Distribution.upload_update(options.dmg_path)
+  end
 end
 
-Distribution.upload_update(dmg_path)
+command :automate do |c|
+  c.syntax = "#{AutoSparkle::NAME} automate [options]"
+  c.description = 'Automate the export, packaging, and distribution of the macOS app'
+  c.option('--project-path PATH', String, 'Path to the Xcode project')
+  c.option('--workspace-path PATH', String, 'Path to the Xcode workspace')
+  c.action do |_args, options|
+    raise 'env name/path is required.' unless options.env
+    raise 'Xcode Project/Workspace path is required.' unless options.workspace_path || options.project_path
+
+    BuildDirectory.create_build_directory
+    Env.initialize(options, Command::AUTOMATE)
+
+    app_version = "#{Env.variables.marketing_version} (#{Env.variables.current_project_version})"
+    puts "Automating the delivery of #{Env.variables.app_display_name} version #{app_version} ..."
+
+    Xcodeproj.update_project_version(options.project_path, options.workspace_path)
+
+    dmg_path = nil
+    with_temporary_keychain do |keychain_info|
+      # 1. Export the app
+      archive_and_sign_hash = {
+        application_cert_name: keychain_info[:application_cert_name],
+        application_team_id: keychain_info[:application_team_id],
+        project_path: options.project_path,
+        workspace_path: options.workspace_path
+      }
+
+      exported_app_path = Packaging.archive_and_sign(archive_and_sign_hash)
+
+      # 2. Package the app
+      dmg_path = Packaging.create_and_sign_dmg(
+        exported_app_path,
+        keychain_info[:application_cert_name],
+        nil
+      )
+    end
+
+    # 3. Distribute the app
+    Distribution.upload_update(dmg_path)
+  end
+end

data/lib/autosparkle/metadata.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module AutoSparkle
+  NAME = 'autosparkle'
+  VERSION = '0.1.1'
+  SUMMARY = 'Automate macOS app delivery outside the App Store'
+  DESCRIPTION = 'Autosparkle is a command-line tool that automates the delivery of macOS apps outside the App Store. It is designed to be used in CI/CD pipelines to automate the process of archiving, signing, notarizing, and distributing macOS apps.'
+end

data/lib/autosparkle/packaging.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'Plist'
 require_relative 'helpers/build_directory_helpers'
 require_relative 'helpers/constants'
 require_relative 'helpers/commands_helpers'
@@ -9,43 +10,50 @@ require_relative 'environment/environment'
 
 # Packaging module to archive and sign the app
 module Packaging
-  def self.archive_and_sign(
-    application_cert_name,
-    application_cert_team_id,
-    options
-  )
-
+  def self.archive_and_sign(hash)
     puts_title 'Archiving and signing the app'
     app_archive_path = BuildDirectory.new_path("#{Env.variables.app_display_name}.xcarchive")
     archive_command = 'xcodebuild clean analyze archive'
     archive_command += " -scheme #{Env.variables.scheme}"
     archive_command += " -archivePath '#{app_archive_path}'"
-    archive_command += " CODE_SIGN_IDENTITY='#{application_cert_name}'"
-    archive_command += " DEVELOPMENT_TEAM='#{application_cert_team_id}'"
+    archive_command += " CODE_SIGN_IDENTITY='#{hash[:application_cert_name]}'"
+    archive_command += " DEVELOPMENT_TEAM='#{hash[:application_team_id]}'"
     archive_command += " -configuration #{Env.variables.configuration}"
     archive_command += " OTHER_CODE_SIGN_FLAGS='--timestamp --options=runtime'"
 
-    archive_command += if options[:workspace_path]
-                         " -workspace #{options[:workspace_path]}"
+    archive_command += if hash[:workspace_path]
+                         " -workspace #{hash[:workspace_path]}"
                        else
-                         " -project #{options[:project_path]}"
+                         " -project #{hash[:project_path]}"
                        end
 
     execute_command(archive_command)
 
     puts_title 'Exporting the app'
-    exported_app_path = export_app(app_archive_path, application_cert_name, application_cert_team_id)
-
-    puts_title 'Signing the Sparkle framework'
-    sign_sparkle_framework(
-      exported_app_path,
-      application_cert_name
+    exported_app_path = export_app(
+      app_archive_path,
+      hash[:application_cert_name],
+      hash[:application_team_id],
+      hash[:output_dir]
     )
 
+    unless hash[:skip_sparkle_steps]
+      puts_title 'Signing the Sparkle framework'
+      sign_sparkle_framework(
+        exported_app_path,
+        hash[:application_cert_name]
+      )
+    end
+
     exported_app_path
   end
 
-  def self.export_app(app_archive_path, application_cert_name, team_id)
+  def self.export_app(
+    app_archive_path,
+    application_cert_name,
+    team_id,
+    output_dir
+  )
     puts_if_verbose 'Exporting the app...'
     export_options = {
       signingStyle: 'automatic',
@@ -71,43 +79,61 @@ module Packaging
     export_command += " -exportOptionsPlist \"#{export_options_file.path}\""
     execute_command(export_command)
 
-    "#{export_app_dir_path}/#{Env.variables.app_display_name}.app"
+    exported_app_path = "#{export_app_dir_path}/#{Env.variables.app_display_name}.app"
+    return exported_app_path unless output_dir
+
+    FileUtils.cp_r(exported_app_path, output_dir)
+    "#{output_dir}/#{Env.variables.app_display_name}.app"
   end
 
-  def self.create_and_sign_dmg(exported_app_path, application_cert_name, keychain_path)
+  def self.create_and_sign_dmg(
+    exported_app_path,
+    application_cert_name,
+    output_dir
+  )
     puts_title "Creating #{Env.variables.app_display_name}.dmg"
     puts_if_verbose 'Creating a DMG for the app...'
     dmg_path = DMG.create(exported_app_path)
 
     # Sign the DMG
     puts_if_verbose 'Signing the DMG...'
-    execute_command("codesign --force --sign \"#{application_cert_name}\" --timestamp --options runtime \"#{dmg_path}\"")
+    signing_dmg_command = "codesign --force --sign \"#{application_cert_name}\""
+    signing_dmg_command += " --timestamp --options runtime \"#{dmg_path}\""
+    execute_command(signing_dmg_command)
 
     # Notarize the DMG
     puts_if_verbose 'Notarizing the DMG...'
-    execute_command("xcrun notarytool submit \"#{dmg_path}\" --keychain-profile \"#{Constants::NOTARIZE_KEYCHAIN_PROFILE}\" --keychain \"#{keychain_path}\" --wait")
+    notarize_command = "xcrun notarytool submit \"#{dmg_path}\""
+    notarize_command += " --keychain-profile \"#{Constants::NOTARIZE_KEYCHAIN_PROFILE}\""
+    notarize_command += " --keychain \"#{Constants::KEYCHAIN_PATH}\""
+    notarize_command += ' --wait'
+    execute_command(notarize_command)
 
     # Staple the notarization ticket
     puts_if_verbose 'Stapling the notarization ticket...'
     execute_command("xcrun stapler staple \"#{dmg_path}\"")
 
-    dmg_path
+    return dmg_path unless output_dir
+
+    FileUtils.cp(dmg_path, output_dir)
+    "#{output_dir}/#{Env.variables.app_display_name}.dmg"
   end
 
   def self.sign_sparkle_framework(exported_app_path, application_cert_name)
-    sparkle_auto_update_path = "#{exported_app_path}/Contents/Frameworks/Sparkle.framework/AutoUpdate"
+    sparkle_framework_path = "#{exported_app_path}/Contents/Frameworks/Sparkle.framework"
+
+    sparkle_auto_update_path = "#{sparkle_framework_path}/AutoUpdate"
     codesign('Signing Sparkle AutoUpdate...', application_cert_name, sparkle_auto_update_path)
 
-    sparkle_updater_path = "#{exported_app_path}/Contents/Frameworks/Sparkle.framework/Updater.app"
+    sparkle_updater_path = "#{sparkle_framework_path}/Updater.app"
     codesign('Signing Sparkle Updater...', application_cert_name, sparkle_updater_path)
 
-    sparkle_installer_xpc_path = "#{exported_app_path}/Contents/Frameworks/Sparkle.framework/XPCServices/Installer.xpc/Contents/MacOS/Installer"
+    sparkle_installer_xpc_path = "#{sparkle_framework_path}/XPCServices/Installer.xpc/Contents/MacOS/Installer"
     codesign('Signing Sparkle Installer XPC Service...', application_cert_name, sparkle_installer_xpc_path)
 
-    sparkle_downloader_xpc_path = "#{exported_app_path}/Contents/Frameworks/Sparkle.framework/XPCServices/Downloader.xpc/Contents/MacOS/Downloader"
+    sparkle_downloader_xpc_path = "#{sparkle_framework_path}/XPCServices/Downloader.xpc/Contents/MacOS/Downloader"
     codesign('Signing Sparkle Downloader XPC Service...', application_cert_name, sparkle_downloader_xpc_path)
 
-    sparkle_framework_path = "#{exported_app_path}/Contents/Frameworks/Sparkle.framework"
     codesign('Signing Sparkle framework...', application_cert_name, sparkle_framework_path)
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: autosparkle
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.1.1
 platform: ruby
 authors:
 - Hadi Dbouk
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-07-06 00:00:00.000000000 Z
+date: 2024-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-s3
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: commander
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.0
 - !ruby/object:Gem::Dependency
   name: dotenv
   requirement: !ruby/object:Gem::Requirement
@@ -107,7 +121,9 @@ files:
 - lib/autosparkle/helpers/version_helpers.rb
 - lib/autosparkle/helpers/xcodeproj_helpers.rb
 - lib/autosparkle/main.rb
+- lib/autosparkle/metadata.rb
 - lib/autosparkle/packaging.rb
+- lib/autosparkle/resources/default-dmg-background.png
 - lib/autosparkle/sparkle/BinaryDelta
 - lib/autosparkle/sparkle/generate_appcast
 - lib/autosparkle/sparkle/generate_keys