henchman-sync 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1f864ccdbb1adb044b16389e17adf74cc7757d26
+  data.tar.gz: 0ed7300956a883823681114bca11bb6985557c4b
+SHA512:
+  metadata.gz: 43a0697682a79bd283b855ec7c1c59dc7f6de7a6547a9b523effeb8e66dce7f7775283e3c93ee961be6ce4fb15f7238adb2f6f96192625c25ecaf21ebb8e9a1f
+  data.tar.gz: b38df428d8700ac444c63ba55fc2dffa778e9b7cbd06f0732c02385e05e41ffaac9ccc1c4c8ce930b165e3beaa4f2c60b7ba8055dc857e3f955d3610dbfe7523

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.12.5

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in henchman.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Greg Merritt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,46 @@
+# Henchman
+
+Henchman is an application which sits on top of iTunes on OS X. It dynamically syncs in music from Dropbox. This way, all music can be kept in the cloud yet you can still use iTunes as your music player.
+
+When you (single) click on a track in iTunes the application will check if that track is available locally. If it is not the application will check if the file is available in Dropbox, and it will be downloaded automatically.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+Or install it yourself as:
+
+    $ gem install henchman
+
+## Usage
+
+Run:
+
+    $ henchman configure
+
+This will guide you through setting up the application, including linking your Dropbox. From here you can run:
+
+    $ henchman start
+
+This starts the henchman daemon. You can now select a track in iTunes which is not available locally, and you will be asked if you'd like to fetch the track from your Dropbox. The application will also automatically download the rest of the album that contains the track you selected.
+
+## Troubleshooting
+
+Running the `configure` command creates a `~/.henchman` direction. This directory contains your configuration file, as well as log files and a shell script used for running the application. If nothing appears to be happening in iTunes after running `henchman start` your best bet is to check the log files.
+
+By default, the application checks if iTunes is open every 10 seconds. It it is, it continues to poll iTunes every 3 seconds to see if a track is selected. If you'd like to change these, you can edit the `config` YAML file. If you edit the `poll_itunes_open` setting, you'll need to stop and re-start the henchman daemon.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/gremerritt/henchman.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "henchman"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/henchman

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require "henchman"
+Henchman.run

data/henchman.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'henchman/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "henchman-sync"
+  spec.version       = Henchman::VERSION
+  spec.authors       = ["Greg Merritt"]
+  spec.email         = ["gremerritt@gmail.com"]
+
+  spec.summary       = %q{Cloud music syncing for iTunes on OS X}
+  spec.description   = %q{OS X app that sits on top of iTunes to sync music with Dropbox}
+  spec.homepage      = "https://www.github.com/gremerritt/henchman"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org/"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "commander", "~> 4.4"
+  spec.add_dependency "dropbox-sdk", "~> 1.6"
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/lib/applescript.rb

@@ -0,0 +1,130 @@
+module Henchman
+
+  class AppleScript
+
+    def setup config
+      @delimiter = config[:delimiter]
+    end
+
+    def get_active_app_script
+      "tell application \"System Events\"\n"\
+  	  "  set activeApp to name of first application process whose frontmost is true\n"\
+  	  "  return activeApp\n"\
+      "end tell"
+    end
+
+    def prompt_script
+      "tell application \"iTunes\"\n"\
+      "  display dialog \"Fetch?\"\n"\
+      "end tell"
+    end
+
+    def update_track_location_script selection, local_file
+      "tell application \"iTunes\"\n"\
+      "  try\n"\
+      "    set data_tracks to "\
+      "      (every track whose artist is \"#{selection[:artist].gsub(/'/){ %q('"'"') }}\" and "\
+      "                         album  is \"#{selection[:album].gsub(/'/){ %q('"'"') }}\"  and "\
+      "                         name   is \"#{selection[:track].gsub(/'/){ %q('"'"') }}\")\n"\
+      "    if (count of data_tracks) is 1 then\n"\
+      "      set location of (item 1 of data_tracks) to "\
+      "        (POSIX file \"#{local_file.gsub(/'/){ %q('"'"') }}\")\n"\
+      "      return 1\n"\
+      "    else\n"\
+      "      return 0\n"\
+      "    end if\n"\
+      "  on error\n"\
+      "    return 0\n"\
+      "  end try\n"\
+      "end tell"
+    end
+
+    def get_selection_script
+      "tell application \"iTunes\"\n"\
+      "  try\n"\
+      "    if class of selection as string is \"file track\" then\n"\
+      "      set data_artist to artist of selection as string\n"\
+      "      set data_album to album of selection as string\n"\
+      "      set data_title to name of selection as string\n"\
+      "      set data_location to POSIX path of (location of selection as string)\n"\
+      "      set str to data_artist & \"#{@delimiter}\" & "\
+      "                 data_album  & \"#{@delimiter}\" & "\
+      "                 data_title  & \"#{@delimiter}\" & "\
+      "                 data_location\n"\
+      "      return str\n"\
+      "    end if\n"\
+      "  on error\n"\
+      "    return \"\"\n"\
+      "  end try\n"\
+      "end tell"
+    end
+
+    def get_album_tracks_script artist, album
+      "tell application \"iTunes\"\n"\
+      "  try\n"\
+      "    set data_tracks to "\
+      "        (every track whose artist is \"#{artist}\" "\
+      "                        and album is \"#{album}\")\n"\
+      "    set data_tracks_str to \"\"\n"\
+      "    repeat with data_track in data_tracks\n"\
+      "      set data_tracks_str to data_tracks_str & (name of data_track) as string\n"\
+			"      if (name of (last item of data_tracks)) is not (name of data_track) then\n"\
+			"        set data_tracks_str to data_tracks_str & \"#{@delimiter}\"\n"\
+			"      end if\n"\
+      "    end repeat\n"\
+      "    return data_tracks_str\n"\
+      "  on error\n"\
+      "    return 0\n"\
+      "  end try\n"\
+      "end tell"
+    end
+
+    def applescript_command(script)
+      "osascript -e '#{script}' 2> /dev/null"
+    end
+
+    def get_selection ret
+      selection = %x( #{applescript_command(get_selection_script)} ).chomp
+      info = selection.split(@delimiter)
+      if info.empty?
+        false
+      elsif info[3] == "/missing value" || !File.exists?(info[3])
+        ret[:artist]   = info[0]
+        ret[:album]    = info[1]
+        ret[:track]    = info[2]
+        true
+      else
+        false
+      end
+    end
+
+    def get_album_tracks_of selection
+      artist = selection[:artist]
+      album  = selection[:album]
+      tracks = %x(#{applescript_command(get_album_tracks_script artist, album)}).chomp
+      tracks = tracks.split(@delimiter)
+      tracks.delete selection[:track]
+      tracks
+    end
+
+    def fetch?
+      (%x(#{applescript_command(prompt_script)}).chomp == "button returned:OK") ? true : false
+    end
+
+    def get_active_app
+      %x(#{applescript_command(get_active_app_script)}).chomp
+    end
+
+    def set_track_location selection, local_file
+      ret = %x(#{applescript_command(update_track_location_script selection, local_file)}).chomp
+      if ret.empty? || ret == '0'
+        puts "Could not update location of #{selection.values.join(':')} to #{local_file}"
+        false
+      else
+        true
+      end
+    end
+
+  end
+
+end

data/lib/configure.rb

@@ -0,0 +1,155 @@
+require "templates"
+require "yaml"
+require "dropbox_sdk"
+require "json"
+
+module Henchman
+  def self.configure
+    config_file = File.expand_path('~/.henchman/config')
+    if !File.exists?(config_file)
+      config = Henchman::Templates.config
+    else
+      config = YAML.load_file(config_file)
+    end
+
+    if config[:dropbox][:key].empty? ||
+       config[:dropbox][:secret].empty? ||
+       config[:dropbox][:access_token].empty? ||
+       agree("Update Dropbox configuration? (y/n) ")
+      begin
+        get_dropbox_credentials config
+      rescue StandardError => err
+        puts err
+        return
+      end
+    end
+
+    client = connect config
+    return if !client
+
+    if config[:dropbox][:root].empty? || agree("\nUpdate music directory in Dropbox? (y/n) ")
+      get_dropbox_root config, client
+    end
+
+    if config[:root].empty? || agree("\nUpdate local music directory? (y/n) ")
+      get_local_root config
+    end
+    
+    Dir.mkdir(File.dirname(config_file)) if !File.exists?(File.dirname(config_file))
+    File.open(config_file, "w") { |f| f.write( config.to_yaml ) }
+    puts "\nConfiguration complete! Run `henchman start` to start the daemon."
+  end
+
+  def self.connect config={}
+    begin
+      config = YAML.load_file(File.expand_path("~/.henchman/config")) if config.empty?
+      client = DropboxClient.new(config[:dropbox][:access_token])
+      account_info = client.account_info()
+      puts "Successfully connected to Dropbox: "
+      puts "  #{account_info['display_name']} [#{account_info['email']}]"
+      return client
+    rescue StandardError => err
+      puts "Error connecting to Dropbox account (#{err}). Try deleting the "\
+           "henchman configuration file (`rm ~/.henchman`) and rerunning "\
+           "`henchman configure`"
+      return false
+    end
+  end
+
+  def self.get_dropbox_credentials config
+    puts "\nYou'll need to create your own Dropbox app to integrate. "\
+         "Head over to https://www.dropbox.com/developers/apps. If "\
+         "you have an app already that you'd like to use, click on "\
+         "that app. If not, click on the 'Create App' link. From "\
+         "here, choose 'Dropbox API', 'Full Dropbox', and finally "\
+         "choose an app name.\n\n"\
+         "Note your app key and app secret, and enter them below. "\
+         "You will then be asked to login and give access to the app. "\
+         "Once you have done this, copy the Authorization Code. You "\
+         "will be prompted to enter it here.\n\n"
+
+    dbx_cfg = config[:dropbox]
+    dbx_cfg[:key]    = ask("Dropbox App Key: ")
+    dbx_cfg[:secret] = ask("Dropbox App Secret: ")
+
+    flow = DropboxOAuth2FlowNoRedirect.new(dbx_cfg[:key], dbx_cfg[:secret])
+    authorize_url = flow.start()
+
+    puts '1. Go to: ' + authorize_url
+    puts '2. Click "Allow" (you might have to log in first)'
+    puts '3. Copy the authorization code'
+
+    code = ask("Enter the authorization code here: ")
+    print "\n"
+    begin
+      dbx_cfg[:access_token], dbx_cfg[:user_id] = flow.finish(code)
+    rescue StandardError => msg
+      dbx_cfg[:key]    = ''
+      dbx_cfg[:secret] = ''
+      raise "Invalid authorization code (#{msg})"
+    end
+  end
+
+  def self.get_dropbox_root config, client
+    # paths = Hash.new
+    # build_dropbox_dirs(paths, client, '/', 0)
+    not_done = true
+    while not_done
+      path = ask("Enter the path to your music directory in Dropbox: (? for help)" )
+      if path == '?'
+        puts "The path to your music directory is a unix-like path. For example: "\
+             "/Some/Directory/Music\n\n"
+        next
+      end
+
+      path = path.chomp('/')
+      begin
+        metadata = client.metadata(path)
+        config[:dropbox][:root] = path
+        puts "Dropbox music path set!\n"
+        not_done = false
+      rescue StandardError => err
+        print "Invalid path. (#{err})"
+        not_done = agree("Try again? (y/n) ")
+      end
+    end
+  end
+
+  # def self.build_dropbox_dirs paths, client, path, level
+  #   return if level == 2
+  #   metadata = client.metadata(path)
+  #   metadata['contents'].each do |elem|
+  #     next if !elem['is_dir']
+  #     paths[elem['path']] = Hash.new
+  #     build_dropbox_dirs(paths[elem['path']], client, elem['path'], level+1)
+  #   end
+  # end
+
+  def self.get_local_root config
+    not_done = true
+    while not_done
+      path = ask("Enter the path to your local music directory: (? for help)" )
+      if path == '?'
+        puts "This is the directory in which local music files will be stored. "\
+             "For example: /Users/yourusernam/Music\n\n"
+        next
+      end
+
+      path = File.expand_path(path.chomp('/'))
+      if File.directory? path
+        config[:root] = path
+        puts "Local music path set!\n"
+        not_done = false
+      elsif File.directory? File.dirname(path)
+        if agree("Directory doesn't exist. Create it? (y/n) ")
+          Dir.mkdir(path)
+          config[:root] = path
+          puts "Local music path set!\n"
+          not_done = false
+        end
+      else
+        puts "Invalid path."
+      end
+    end
+  end
+end

data/lib/core.rb

@@ -0,0 +1,125 @@
+require "dropbox.rb"
+require "applescript.rb"
+require "yaml"
+
+module Henchman
+
+  class Core
+
+    def self.run
+      @appleScript = Henchman::AppleScript.new
+
+      begin
+        cache_file = File.expand_path("~/.henchman/cache")
+        @ignore = YAML.load_file(cache_file)
+      rescue StandardError => err
+        puts "Error opening cache file (#{err})"
+        @ignore = Hash.new
+      end
+      @ignore.default = 0
+
+      threads = []
+      update_cache = false
+
+      while itunes_is_active?
+        begin
+          @config = YAML.load_file(File.expand_path('~/.henchman/config'))
+        rescue StandardError => err
+          puts "Error opening config file. Try rerunning `henchman configure`"
+          return
+        end
+
+        @appleScript.setup @config
+        begin
+          @dropbox = Henchman::DropboxAssistant.new @config
+        rescue
+          puts "Error connecting to Dropbox. Try rerunning `henchman configure`"
+          return
+        end
+
+        selection = Hash.new
+        track_selected = @appleScript.get_selection selection
+
+        if track_selected && @ignore[selection[:artist]] < (Time.now.to_i - @config[:reprompt_timeout])
+          update_cache = true
+          @ignore.delete selection[:artist]
+          if @appleScript.fetch?
+            puts "searching"
+            begin
+              # first download the selected track
+              dropbox_path   = @dropbox.search_for selection
+              file_save_path = @dropbox.download selection, dropbox_path
+
+              # if we downloaded it, update the location of the track in iTunes
+              unless !file_save_path
+                updated = @appleScript.set_track_location selection, file_save_path
+                # if the update failed, cleanup that directory and don't bother
+                # doing the rest of the album
+                if !updated
+                  cleanup file_save_path
+                  next
+                end
+
+                # now that we've gotten the selected track, spawn off another process
+                # to download the rest of the tracks on the album - spatial locality FTW
+                album_tracks = @appleScript.get_album_tracks_of selection
+                threads << Thread.new{ download_album_tracks selection, album_tracks }
+              end
+            rescue StandardError => err
+              puts err
+              next
+            end
+          else
+            @ignore[selection[:artist]] = Time.now.to_i
+          end
+        end
+        sleep @config[:poll_track]
+      end
+
+      threads.each { |thr| thr.join }
+      File.open(cache_file, "w") { |f| f.write( @ignore.to_yaml ) } if update_cache
+    end
+
+    def self.itunes_is_active?
+      @appleScript.get_active_app == 'iTunes'
+    end
+
+    def self.download_album_tracks selection, album_tracks
+      album_tracks.each do |album_track|
+        selection[:track] = album_track
+        begin
+          # first download the selected track
+          dropbox_path   = @dropbox.search_for selection
+          file_save_path = @dropbox.download selection, dropbox_path
+
+          # if we downloaded it, update the location of the track in iTunes
+          unless !file_save_path
+            updated = @appleScript.set_track_location selection, file_save_path
+            # if the update failed, remove that file
+            if !updated
+              cleanup file_save_path
+              next
+            end
+          end
+        rescue StandardError => err
+          puts err
+          next
+        end
+      end
+    end
+
+    def self.cleanup file_save_path
+      File.delete file_save_path
+      while File.dirname(file_save_path) != @config[:root]
+        file_save_path = File.dirname(file_save_path)
+        begin
+          Dir.rmdir(file_save_path)
+        rescue SystemCallError => msg
+          break
+        end
+      end
+    end
+
+  end
+
+end

data/lib/dropbox.rb

@@ -0,0 +1,90 @@
+require 'dropbox_sdk'
+require 'yaml'
+require 'json'
+
+module Henchman
+
+  class DropboxAssistant
+
+    def initialize config
+      begin
+        @config = config
+        @client = DropboxClient.new(@config[:dropbox][:access_token])
+        true
+      rescue DropboxError => msg
+        puts "Couldn't connect to Dropbox (#{msg}). \n"\
+             "Run `henchman stop` then `henchman configure` \n"\
+             "to configure Dropbox connection."
+        false
+      end
+    end
+
+    def download selection, dropbox_path
+      puts "downloading #{selection[:track]}"
+      begin
+        # download the file
+        content = @client.get_file(dropbox_path)
+
+        # make sure we have the directory to put it in
+        trgt_dir = File.join @config[:root], selection[:artist], selection[:album]
+        system 'mkdir', '-p', trgt_dir
+
+        # save the file
+        file_save_path = File.join trgt_dir, File.basename(dropbox_path)
+        open(file_save_path, 'w') {|f| f.puts content }
+        file_save_path
+      rescue DropboxError => msg
+        puts "Error downloading Dropbox file #{dropbox_path}: #{msg}"
+        false
+      rescue StandardError => msg
+        puts "Error saving Dropbox file #{dropbox_path} to #{trgt_dir}: #{msg}"
+        false
+      end
+    end
+
+    def search_for selection
+      # search Dropbox for the file
+      results = @client.search(@config[:dropbox][:root], selection[:track])
+
+      # get rid of any results that are directories
+      results.reject! { |result| result['is_dir'] }
+
+      # if we still don't have any results, try dropping any brackets and paranthesis
+      if results.empty? && (selection[:track].match(%r( *\[.*\] *)) || selection[:track].match(%r( *\(.*\) *)))
+        track = selection[:track].gsub(%r( *\[.*\] *), " ").gsub(%r( *\(.*\) *), " ")
+        results = @client.search(@config[:dropbox][:root], track)
+        results.reject! { |result| result['is_dir'] }
+      end
+
+      # if there were no results, raise err
+      if results.empty?
+        raise "Track not found in Dropbox: #{selection.inspect}"
+
+      # if there's only one result, return it
+      elsif results.length == 1
+        results[0]['path']
+
+      # if there are multiple results, score them based on artist + album
+      else
+        scores = Hash.new 0
+        results.each do |result|
+          [:artist, :album].each do |identifier|
+            tokens = selection[identifier].downcase
+                                          .gsub(%r( +), " ")
+                                          .gsub(%r(-+), "-")
+                                          .strip
+                                          .split(/[\s-]/)
+            tokens.each do |token|
+              scores[result['path']] += 1 if result['path'].downcase.include? token
+            end
+          end
+        end
+
+        # return the path that has the highest score
+        (scores.sort_by { |path, score| score })[-1][0]
+      end
+    end
+
+  end
+
+end

data/lib/henchman/version.rb

@@ -0,0 +1,3 @@
+module Henchman
+  VERSION = "0.1.0"
+end

data/lib/henchman.rb

@@ -0,0 +1,47 @@
+require "henchman/version"
+require "configure"
+require "launchd_handler"
+require "core"
+require "commander/import"
+require "yaml"
+
+module Henchman
+  def Henchman.run
+    program :name, 'Henchman'
+    program :version, Henchman::VERSION
+    program :description, 'Cloud music syncing for iTunes on OS X'
+
+    command :start do |c|
+      c.syntax = 'henchman start'
+      c.description = 'Starts the henchman daemon'
+      c.action do |args, options|
+        Henchman::LaunchdHandler.start
+      end
+    end
+
+    command :stop do |c|
+      c.syntax = 'henchman stop'
+      c.description = 'Stops the henchman daemon'
+      c.action do |args, options|
+        Henchman::LaunchdHandler.stop
+      end
+    end
+
+    command :configure do |c|
+      c.syntax = 'henchman configure'
+      c.description = 'Configures the henchman client'
+      c.action do |args, options|
+        Henchman.configure
+      end
+    end
+
+    command :run do |c|
+      c.syntax = 'henchman run'
+      c.description = 'Main interface into henchman. Should not be ran manually.'
+      c.action do |args, options|
+        Henchman::Core.run
+      end
+    end
+
+  end
+end

data/lib/launchd_handler.rb

@@ -0,0 +1,55 @@
+require 'open-uri'
+
+module Henchman
+
+  class LaunchdHandler
+
+    def self.start
+      if !internet_connection?
+        puts "No internet connection detected - unable to verify correct configuration."
+        return if !agree("Launch henchman anyways? (y/n) ")
+      else
+        puts "Checking configuration"
+        return if !Henchman.connect
+      end
+
+      puts "Creating agent"
+      plist      = Henchman::Templates.plist
+      plist_path = File.expand_path("~/Library/LaunchAgents/com.henchman.plist")
+      shell_script_path = File.expand_path("~/.henchman/run.sh")
+      cache_path        = File.expand_path("~/.henchman/cache")
+      File.write(plist_path, plist)
+      File.write(shell_script_path, Henchman::Templates.shell_script)
+      File.open(cache_path, "w") { |f| f.write( {}.to_yaml ) }
+
+      puts "Launching agent"
+      `chmod +x #{shell_script_path}`
+      `launchctl load #{plist_path}`
+
+      puts "Launched successful! You are now running henchman."
+    end
+
+    def self.stop
+      puts "Stopping agents"
+      plist_path = File.expand_path("~/Library/LaunchAgents/com.henchman.plist")
+      `launchctl unload #{plist_path}`
+      `rm #{plist_path}`
+      `rm #{File.expand_path("~/.henchman/run.sh")}`
+      `rm #{File.expand_path("~/.henchman/cache")}`
+      `rm #{File.expand_path("~/.henchman/stdout.log")}`
+      `rm #{File.expand_path("~/.henchman/stderr.log")}`
+
+      puts "Successfully stopped henchman"
+    end
+
+    def self.internet_connection?
+      begin
+        true if open("https://www.dropbox.com/")
+      rescue
+        false
+      end
+    end
+
+  end
+
+end

data/lib/templates.rb

@@ -0,0 +1,47 @@
+module Henchman
+  class Templates
+    def self.plist
+      config = YAML.load_file(File.expand_path('~/.henchman/config'))
+
+      "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"\
+      "<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" "\
+      "\"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"\
+      "<plist version=\"1.0\">\n"\
+      "<dict>\n"\
+      "\t<key>Label</key>\n"\
+      "\t<string>henchman</string>\n"\
+      "\t<key>ProgramArguments</key>\n"\
+      "\t<array>\n"\
+      "\t\t<string>#{File.expand_path('~/.henchman/run.sh')}</string>\n"\
+      "\t</array>\n"\
+      "\t<key>StartInterval</key>\n"\
+      "\t<integer>#{config[:poll_itunes_open]}</integer>\n"\
+      "\t<key>StandardOutPath</key>\n"\
+      "\t<string>#{File.expand_path('~/.henchman/stdout.log')}</string>\n"\
+      "\t<key>StandardErrorPath</key>\n"\
+      "\t<string>#{File.expand_path('~/.henchman/stderr.log')}</string>\n"\
+      "</dict>\n"\
+      "</plist>"
+    end
+
+    def self.shell_script
+      "#!/bin/sh\n"\
+      "#{`which henchman`.chomp} run"
+    end
+
+    def self.config
+      yml = {
+              :dropbox => {:key => '',
+                           :secret => '',
+                           :access_token => '',
+                           :user_id => '',
+                           :root     => ''},
+              :root => '',
+              :poll_itunes_open => 10,
+              :poll_track => 3,
+              :reprompt_timeout => 300,
+              :delimiter => '|~|'
+            }
+    end
+  end
+end

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: henchman-sync
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Greg Merritt
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-06-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: commander
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.4'
+- !ruby/object:Gem::Dependency
+  name: dropbox-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: OS X app that sits on top of iTunes to sync music with Dropbox
+email:
+- gremerritt@gmail.com
+executables:
+- henchman
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/henchman
+- henchman.gemspec
+- lib/applescript.rb
+- lib/configure.rb
+- lib/core.rb
+- lib/dropbox.rb
+- lib/henchman.rb
+- lib/henchman/version.rb
+- lib/launchd_handler.rb
+- lib/templates.rb
+homepage: https://www.github.com/gremerritt/henchman
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org/
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Cloud music syncing for iTunes on OS X
+test_files: []