fastlyctl 1.0.1

data/lib/fastlyctl/commands/acl.rb

@@ -0,0 +1,88 @@
+module FastlyCTL
+  class CLI < Thor
+    desc "acl ACTION ACL_NAME IP_OR_SUBNET", "Manipulate ACLS.\n  Actions:\n    create: Create an ACL\n
+    delete: Delete an ACL\n
+    list: Provide a list of ACLs on this service\n
+    add: Add an IP/subnet to an ACL\n
+    remove: Remove an IP/subnet from an ACL\n
+    list_ips: List all IPs/subnets in the ACL\n
+    bulk_add: Perform operations on the ACL in bulk. A list of operations in JSON format should be specified in the ip field. Documentation on this format can be found here: https://docs.fastly.com/api/config#acl_entry_c352ca5aee49b7898535cce488e3ba82"
+    method_option :service, :aliases => ["--s"]
+    method_option :version, :aliases => ["--v"]
+    method_option :negate, :aliases => ["--n"]
+    def acl(action, name=false, ip=false)
+      id = FastlyCTL::Utils.parse_directory unless options[:service]
+      id ||= options[:service]
+
+      abort "Could not parse service id from directory. Specify service id with --service or use from within service directory." unless id
+
+      version = FastlyCTL::Fetcher.get_writable_version(id) unless options[:version]
+      version ||= options[:version]
+
+      case action
+      when "create"
+        abort "Must specify name for ACL" unless name
+        FastlyCTL::Fetcher.api_request(:post, "/service/#{id}/version/#{version}/acl", params: { name: name })
+
+        say("ACL #{name} created.")
+      when "delete"
+        abort "Must specify name for ACL" unless name
+        FastlyCTL::Fetcher.api_request(:delete, "/service/#{id}/version/#{version}/acl/#{name}")
+
+        say("ACL #{name} deleted.")
+      when "list"
+        resp = FastlyCTL::Fetcher.api_request(:get, "/service/#{id}/version/#{version}/acl")
+
+        say("No ACLs on service in this version.") unless resp.length > 0
+
+        resp.each do |d|
+          puts "#{d["id"]} - #{d["name"]}"
+        end
+      when "add"
+        abort "Must specify name for ACL" unless name
+        abort "Must specify IP" unless ip
+        acl = FastlyCTL::Fetcher.api_request(:get, "/service/#{id}/version/#{version}/acl/#{name}")
+        FastlyCTL::Fetcher.api_request(:post, "/service/#{id}/acl/#{acl["id"]}/entry", params: { ip: ip, negated: options.key?(:negate) ? "1" : "0" })   
+
+        say("#{ip} added to ACL #{name}.")   
+      when "remove"
+        abort "Must specify name for ACL" unless name
+        abort "Must specify IP for ACL entry" unless ip
+        acl = FastlyCTL::Fetcher.api_request(:get, "/service/#{id}/version/#{version}/acl/#{name}")
+        entries = FastlyCTL::Fetcher.api_request(:get, "/service/#{id}/acl/#{acl["id"]}/entries")
+
+        entry = false
+        entries.each do |e|
+          if e["ip"] == ip
+            entry = e
+            break
+          end
+        end
+
+        abort "IP #{ip} not found in ACL" unless entry
+
+        FastlyCTL::Fetcher.api_request(:delete, "/service/#{id}/acl/#{acl["id"]}/entry/#{entry["id"]}")
+
+        say("IP #{ip} removed from ACL #{name}.")
+      when "list_ips"
+        abort "Must specify name for ACL" unless name
+        acl = FastlyCTL::Fetcher.api_request(:get, "/service/#{id}/version/#{version}/acl/#{name}")
+        entries = FastlyCTL::Fetcher.api_request(:get, "/service/#{id}/acl/#{acl["id"]}/entries")
+
+        say("No items in ACL.") unless entries.length > 0
+        entries.each do |i|
+          puts "#{i["ip"]} - Negated: #{i["negated"] == "0" ? "false" : "true"}"
+        end
+      when "bulk_add"
+        abort "Must specify name for ACL" unless name
+        abort "Must specify JSON blob of operations in ip field. Documentation on this can be found here: https://docs.fastly.com/api/config#acl_entry_c352ca5aee49b7898535cce488e3ba82" unless ip
+        acl = FastlyCTL::Fetcher.api_request(:get, "/service/#{id}/version/#{version}/acl/#{name}")
+        FastlyCTL::Fetcher.api_request(:patch, "/service/#{id}/acl/#{acl["id"]}/items", {body: ip, headers: {"Content-Type" => "application/json"}})
+
+        say("Bulk add operation completed successfully.")
+      else
+        abort "#{action} is not a valid command"
+      end
+    end
+  end
+end

data/lib/fastlyctl/commands/activate.rb

@@ -0,0 +1,27 @@
+module FastlyCTL
+  class CLI < Thor
+    desc "activate", "Activates the latest writable service version, or the version number provided in the --version flag."
+    method_option :service, :aliases => ["--s"]
+    method_option :version, :aliases => ["--v"]
+    method_option :comment, :aliases => ["--c"]
+    def activate
+      id = FastlyCTL::Utils.parse_directory unless options[:service]
+      id ||= options[:service]
+
+      abort "Could not parse service id from directory. Use --s <service> to specify, vcl download, then try again." unless id
+
+      writable_version = FastlyCTL::Fetcher.get_writable_version(id) unless options[:version]
+      writable_version ||= options[:version].to_i
+
+      if options.key?(:comment)
+        FastlyCTL::Fetcher.api_request(:put, "/service/#{id}/version/#{writable_version}",{
+          params: {comment: options[:comment]}
+        })
+      end
+
+      FastlyCTL::Fetcher.api_request(:put, "/service/#{id}/version/#{writable_version}/activate")
+
+      say("Version #{writable_version} on #{id} activated.")
+    end
+  end
+end

data/lib/fastlyctl/commands/clone.rb

@@ -0,0 +1,40 @@
+module FastlyCTL
+  class CLI < Thor
+    desc "clone SERVICE_ID TARGET_SERVICE_ID", "Clone a service version to another service."
+    method_option :version, :aliases => ["--v"]
+    method_option :skip_logging, :aliases => ["--sl"]
+    def clone(id,target_id)
+      version = FastlyCTL::Fetcher.get_active_version(id) unless options[:version]
+      version ||= options[:version]
+
+      target_version = FastlyCTL::Fetcher.api_request(:post, "/service/#{target_id}/version")["number"]
+
+      puts "Copying #{id} version #{version} to #{target_id} version #{target_version}..."
+
+      FastlyCTL::CloneUtils::OBJECT_TYPES.each do |type,meta|
+        next if (type.include?("logging/") && options.key?(:skip_logging))
+
+        response = FastlyCTL::Fetcher.api_request(:get, "/service/#{id}/version/#{version}/#{type}")
+        response = [response] unless response.is_a?(Array)
+
+        next unless response.length > 0
+
+        puts "Copying #{response.length} " + (response.length == 1 ? FastlyCTL::CloneUtils.unpluralize(type) : FastlyCTL::CloneUtils.pluralize(type))
+
+        response.each do |obj|
+          FastlyCTL::CloneUtils.copy(obj,type,target_id,target_version)
+        end
+      end
+
+      target_active_version = FastlyCTL::Fetcher.get_active_version(target_id)
+      response = FastlyCTL::Fetcher.api_request(:get, "/service/#{target_id}/version/#{target_active_version}/domain")
+      return unless response.length > 0
+
+      puts "Restoring #{response.length} " + (response.length == 1 ? "domain" : "domains" + " from #{target_id} version #{target_active_version}...")
+
+      response.each do |domain|
+        FastlyCTL::CloneUtils.copy(domain,"domain",target_id,target_version)
+      end
+    end
+  end
+end

data/lib/fastlyctl/commands/copy.rb

@@ -0,0 +1,41 @@
+module FastlyCTL
+  class CLI < Thor
+    desc "copy SERVICE_ID TARGET_SERVICE_ID OBJECT_TYPE OBJECT_NAME", "Copy an object from one service to another\n  Available Object Types: #{FastlyCTL::CloneUtils::OBJECT_TYPES.keys.join(', ')}"
+    method_option :version1, :aliases => ["--v1"]
+    method_option :version2, :aliases => ["--v2"]
+    def copy(id,target_id,obj_type,obj_name=false)
+      abort "Object name must be specified for all object types except settings" if (obj_name === false && obj_type != "settings")
+
+      source_version = FastlyCTL::Fetcher.get_active_version(id) unless options[:version1]
+      source_version ||= options[:version1]
+      target_version = FastlyCTL::Fetcher.get_writable_version(target_id) unless options[:version2]
+      target_version ||= options[:version2]
+
+      unless FastlyCTL::CloneUtils::OBJECT_TYPES.include?(obj_type)
+        abort "Object type #{obj_type} is invalid. Must be one of: #{FastlyCTL::CloneUtils::OBJECT_TYPES.keys.join(', ')}"
+      end
+
+      path = "/service/#{id}/version/#{source_version}/#{obj_type}"
+      path += "/#{obj_name}" unless obj_type == "settings"
+      obj = FastlyCTL::Fetcher.api_request(:get, path)
+
+      if (obj_type == "settings")
+        puts "Copying settings from #{id} version #{source_version} to #{target_id} version #{target_version}..."
+      else
+        existing_obj = FastlyCTL::Fetcher.api_request(:get, "/service/#{target_id}/version/#{target_version}/#{obj_type}/#{obj_name}",{
+          expected_responses: [200,404]
+        })
+
+        if existing_obj.key?("name")
+          abort unless yes?("A #{FastlyCTL::CloneUtils.unpluralize(obj_type)} named #{obj_name} already exists on #{target_id} version #{target_version}. Delete it and proceed?")
+
+          FastlyCTL::Fetcher.api_request(:delete,"/service/#{target_id}/version/#{target_version}/#{obj_type}/#{obj_name}")
+        end
+
+        puts "Copying #{FastlyCTL::CloneUtils.unpluralize(obj_type)} #{obj_name} from #{id} version #{source_version} to #{target_id} version #{target_version}..."
+      end
+
+      FastlyCTL::CloneUtils.copy(obj,obj_type,target_id,target_version)
+    end
+  end
+end

data/lib/fastlyctl/commands/create_service.rb

@@ -0,0 +1,18 @@
+module FastlyCTL
+  class CLI < Thor
+    desc "create_service SERVICE_NAME", "Create a blank service. If --customer is supplied and you are an admin, the command will move the service to that customer's account."
+    method_option :customer, :aliases => ["--c"]
+    def create_service(name)
+      service = FastlyCTL::Fetcher.api_request(:post, "/service", { params: { name: name }})
+
+      if options[:customer]
+        say("This command works by creating a service on your account and moving it to the target account.")
+        self.move(service["id"],options[:customer])
+      end
+
+      if yes?("Service #{service["id"]} has been created. Would you like to open the configuration page?")
+        FastlyCTL::Utils.open_service(service["id"])
+      end
+    end
+  end
+end

data/lib/fastlyctl/commands/dictionary.rb

@@ -0,0 +1,75 @@
+module FastlyCTL
+  class CLI < Thor
+    desc "dictionary ACTION DICTIONARY_NAME KEY VALUE", "Manipulate edge dictionaries.\n  Actions:\n    create: Create a dictionary\n
+    delete: Delete a dictionary\n
+    list: Provide a list of dictionaries on this service\n
+    upsert: Update a key in a dictionary if it exists. Add the key if it does not.\n
+    remove: Remove a key from a dictionary\n
+    list_items: List all keys in the dictionary\n
+    bulk_add: Perform operations on the dictionary in bulk. A list of operations in JSON format should be specified in the key field. Documentation on this format can be found here: https://docs.fastly.com/api/config#dictionary_item_dc826ce1255a7c42bc48eb204eed8f7f"
+    method_option :service, :aliases => ["--s"]
+    method_option :version, :aliases => ["--v"]
+    def dictionary(action, name=false, key=false, value=false)
+      id = FastlyCTL::Utils.parse_directory unless options[:service]
+      id ||= options[:service]
+
+      abort "Could not parse service id from directory. Specify service id with --service or use from within service directory." unless id
+
+      version = FastlyCTL::Fetcher.get_writable_version(id) unless options[:version]
+      version ||= options[:version]
+
+      case action
+      when "create"
+        abort "Must specify name for dictionary" unless name
+        FastlyCTL::Fetcher.api_request(:post, "/service/#{id}/version/#{version}/dictionary", params: { name: name })
+
+        say("Dictionary #{name} created.")
+      when "delete"
+        abort "Must specify name for dictionary" unless name
+        FastlyCTL::Fetcher.api_request(:delete, "/service/#{id}/version/#{version}/dictionary/#{name}")
+
+        say("Dictionary #{name} deleted.")
+      when "list"
+        resp = FastlyCTL::Fetcher.api_request(:get, "/service/#{id}/version/#{version}/dictionary")
+
+        say("No dictionaries on service in this version.") unless resp.length > 0
+
+        resp.each do |d|
+          puts "#{d["id"]} - #{d["name"]}"
+        end
+      when "upsert"
+        abort "Must specify name for dictionary" unless name
+        abort "Must specify key and value for dictionary item" unless (key && value)
+        dict = FastlyCTL::Fetcher.api_request(:get, "/service/#{id}/version/#{version}/dictionary/#{name}")
+        FastlyCTL::Fetcher.api_request(:put, "/service/#{id}/dictionary/#{dict["id"]}/item/#{key}", params: { item_value: value })   
+
+        say("Dictionary item #{key} set to #{value}.")   
+      when "remove"
+        abort "Must specify name for dictionary" unless name
+        abort "Must specify key for dictionary item" unless key
+        dict = FastlyCTL::Fetcher.api_request(:get, "/service/#{id}/version/#{version}/dictionary/#{name}")
+        FastlyCTL::Fetcher.api_request(:delete, "/service/#{id}/dictionary/#{dict["id"]}/item/#{key}")
+
+        say("Item #{key} removed from dictionary #{name}.")
+      when "list_items"
+        abort "Must specify name for dictionary" unless name
+        dict = FastlyCTL::Fetcher.api_request(:get, "/service/#{id}/version/#{version}/dictionary/#{name}")
+        resp = FastlyCTL::Fetcher.api_request(:get, "/service/#{id}/dictionary/#{dict["id"]}/items")
+
+        say("No items in dictionary.") unless resp.length > 0
+        resp.each do |i|
+          puts "#{i["item_key"]} : #{i["item_value"]}"
+        end
+      when "bulk_add"
+        abort "Must specify name for dictionary" unless name
+        abort "Must specify JSON blob of operations in key field. Documentation on this can be found here: https://docs.fastly.com/api/config#dictionary_item_dc826ce1255a7c42bc48eb204eed8f7f" unless key
+        dict = FastlyCTL::Fetcher.api_request(:get, "/service/#{id}/version/#{version}/dictionary/#{name}")
+        FastlyCTL::Fetcher.api_request(:patch, "/service/#{id}/dictionary/#{dict["id"]}/items", {body: key, headers: {"Content-Type" => "application/json"}})
+
+        say("Bulk add operation completed successfully.")
+      else
+        abort "#{action} is not a valid command"
+      end
+    end
+  end
+end

data/lib/fastlyctl/commands/diff.rb

@@ -0,0 +1,97 @@
+module FastlyCTL
+  class CLI < Thor
+    desc "diff", "Diff two service versions. By default, diffs the active version of the service assumed from the current directory with the local VCL in the current directory. Options allow you to specify different versions and different services."
+    method_option :version1, :aliases => ["--v1"]
+    method_option :version2, :aliases => ["--v2"]
+    method_option :service1, :aliases => ["--s1"]
+    method_option :service2, :aliases => ["--s2"]
+    method_option :generated, :aliases => ["--g"]
+    def diff
+      if options[:service1]
+        service1 = options[:service1]
+      else
+        service1 = FastlyCTL::Utils.parse_directory
+        abort "Could not parse service id from directory" unless service1
+      end
+      if options[:service2]
+        service2 = options[:service2]
+      else
+        service2 = FastlyCTL::Utils.parse_directory
+
+        # use service1 for both if unspecified
+        service2 = service1 unless service2
+      end
+
+      # diffing different services - no references to local vcl here
+      if service1 != service2
+        version1 = options.key?(:version1) ? options[:version1] : FastlyCTL::Fetcher.get_active_version(service1)
+        version2 = options.key?(:version2) ? options[:version2] : FastlyCTL::Fetcher.get_active_version(service2)
+      end
+
+      # diffing the same service
+      if service1 == service2
+        # if both are specified, diff them
+        if options[:version1] && options[:version2]
+          version1 = options[:version1]
+          version2 = options[:version2]
+        end
+        # if version1 is not specified, diff local with version 2
+        if !options[:version1] && options[:version2]
+          version1 = false
+          version2 = options[:version2]
+        end
+        # if version2 is not specified, diff local with version 1
+        if options[:version1] && !options[:version2]
+          version1 = options[:version1]
+          version2 = false
+        end
+        if !options[:version1] && !options[:version2]
+          # if neither are specified, diff local with active version
+          version1 = FastlyCTL::Fetcher.get_active_version(service2)
+          version2 = false
+        end
+      end
+
+      say("Diffing#{options[:generated] ? " generated VCL for" : ""} #{service1} #{version1 ? "version "+version1.to_s : "local VCL"} with #{service2} #{version2 ? "version "+version2.to_s : "local VCL"}.")
+
+      if version1
+        v1_vcls = FastlyCTL::Fetcher.get_vcl(service1, version1,options[:generated])
+      else
+        abort "Cannot diff generated VCL with local VCL" if options[:generated]
+        Dir.foreach(Dir.pwd) do |p|
+          next unless File.file?(p)
+          next unless p =~ /\.vcl$/
+
+          v1_vcls ||= Array.new
+          v1_vcls << {
+            "name" => p.chomp(".vcl"),
+            "content" => File.read(p)
+          }
+        end
+      end
+
+      if version2
+        v2_vcls = FastlyCTL::Fetcher.get_vcl(service2, version2,options[:generated])
+      else
+        abort "Cannot diff generated VCL with local VCL" if options[:generated]
+        Dir.foreach(Dir.pwd) do |p|
+          next unless File.file?(p)
+          next unless p =~ /\.vcl$/
+
+          v2_vcls ||= Array.new
+          v2_vcls << {
+            "name" => p.chomp(".vcl"),
+            "content" => File.read(p)
+          }
+        end
+      end
+
+      if options[:generated]
+        say(FastlyCTL::Utils.diff_generated(v1_vcls,v2_vcls))
+      else
+        say(FastlyCTL::Utils.diff_versions(v1_vcls,v2_vcls))
+      end
+
+    end
+  end
+end

data/lib/fastlyctl/commands/domain.rb

@@ -0,0 +1,47 @@
+module FastlyCTL
+  class CLI < Thor
+    desc "domain ACTION HOST", "Manipulate domains on a service. Available actions are create, delete, list and check. Create, delete and check take a host argument. Additionally, check can take the argument \"all\" to check all domains."
+    method_option :service, :aliases => ["--s"]
+    method_option :version, :aliases => ["--v"]
+    def domain(action,host=false)
+      id = FastlyCTL::Utils.parse_directory unless options[:service]
+      id ||= options[:service]
+
+      abort "Could not parse service id from directory. Use --s <service> to specify, vcl download, then try again." unless id
+
+      version = FastlyCTL::Fetcher.get_writable_version(id) unless options[:version]
+      version ||= options[:version].to_i
+
+      case action
+      when "create"
+        FastlyCTL::Fetcher.api_request(:post,"/service/#{id}/version/#{version}/domain",{
+          params: {
+            name: host,
+          }
+        })
+        say("#{host} created on #{id} version #{version}")
+      when "delete"
+        FastlyCTL::Fetcher.api_request(:delete,"/service/#{id}/version/#{version}/domain/#{host}")
+        say("#{host} deleted on #{id} version #{version}")
+      when "list"
+        domains = FastlyCTL::Fetcher.api_request(:get,"/service/#{id}/version/#{version}/domain")
+        say("Listing all domains for #{id} version #{version}")
+        domains.each do |d|
+          puts d["name"]
+        end
+      when "check"
+        if host == "all"
+          domains = FastlyCTL::Fetcher.api_request(:get,"/service/#{id}/version/#{version}/domain/check_all")
+        else
+          domains = [FastlyCTL::Fetcher.api_request(:get,"/service/#{id}/version/#{version}/domain/#{host}/check")]
+        end
+
+        domains.each do |d|
+          say("#{d[0]["name"]} -> #{d[1]}")
+        end
+      else
+        abort "#{action} is not a valid command"
+      end
+    end
+  end
+end

data/lib/fastlyctl/commands/download.rb

@@ -0,0 +1,85 @@
+module FastlyCTL
+  class CLI < Thor
+    desc "download VCL_NAME", "Download VCLs. If no name is specified, downloads all the VCLs on the service."
+    method_option :service, :aliases => ["--s"]
+    method_option :version, :aliases => ["--v"]
+    method_option :generated, :aliases => ["--g"]
+    def download(vcl_name=false)
+      parsed_id = FastlyCTL::Utils.parse_directory
+
+      if options[:service]
+        abort "Already in a service directory, go up one level in order to specify"\
+              "service id with --service." if parsed_id
+        id = options[:service]
+        parsed = false
+      else
+        abort "Could not parse service id from directory. Specify service id with "\
+              "--service option or use from within service directory." unless parsed_id
+        id = parsed_id
+        parsed = true
+      end
+
+      service = FastlyCTL::Fetcher.api_request(:get, "/service/#{id}/details")
+
+      version = FastlyCTL::Fetcher.get_active_version(id) unless options[:version]
+      version ||= options[:version]
+
+      if options[:generated]
+        generated = FastlyCTL::Fetcher.api_request(:get, "/service/#{id}/version/#{version}/generated_vcl")
+        File.open("generated.vcl", 'w+') {|f| f.write(generated["content"]) }
+        abort "Generated VCL for version #{version} written to generated.vcl."
+      end
+
+      vcl = FastlyCTL::Fetcher.get_vcl(id, version)
+      snippet = FastlyCTL::Fetcher.get_snippets(id, version)
+
+      sname = service["name"]
+      if sname.include? "/"
+        sname = sname.tr("/","_")
+      end
+
+      folder_name = parsed ? "./" : "#{sname} - #{service["id"]}/"
+      Dir.mkdir(folder_name) unless (File.directory?(folder_name) || parsed)
+
+      if vcl
+        vcl.each do |v,k|
+          next if (vcl_name && vcl_name != v["name"])
+
+          filename = "#{folder_name}#{v["name"]}.vcl"
+
+          if File.exist?(filename)
+            unless yes?("Are you sure you want to overwrite #{filename}")
+              say("Skipping #{filename}")
+              next
+            end
+          end
+
+          File.open(filename, 'w+') {|f| f.write(v["content"]) }
+
+          say("VCL content for version #{version} written to #{filename}")
+        end
+      end
+
+      if snippet
+        snippet.each do |s,k|
+          filename = "#{folder_name}#{s["name"]}.snippet"
+
+          if File.exist?(filename)
+            unless yes?("Are you sure you want to overwrite #{filename}")
+              say("Skipping #{filename}")
+              next
+            end
+          end
+
+          File.open(filename, 'w+') {|f| f.write(s["content"]) }
+
+          say("Snippet content for version #{version} written to #{filename}")
+        end
+      end
+
+      unless vcl || snippet
+        say("No VCLs or snippets on this service, however a folder has been created. Create VCLs in this folder and upload.")
+      end
+    end
+  end
+end

data/lib/fastlyctl/commands/login.rb

@@ -0,0 +1,58 @@
+module FastlyCTL
+  class CLI < Thor
+    desc "login", "Logs into the app. Required before doing anything else."
+    def login
+      if FastlyCTL::Token
+        abort unless yes?("You already have an access token, are you sure you want to authenticate again?")
+      end
+
+      if yes?("Does your organization use SSO to login to Fastly? If so, type \"yes\" and create a 'global' or 'root' scoped token in your web browser. Copy the token to the file ~/.fastlyctl_token and save it.")
+        Launchy.open(FastlyCTL::FASTLY_APP + "/account/personal/tokens/new")
+        abort
+      end
+
+      say("Proceeding with username/password login...")
+
+      login_results = FastlyCTL::Fetcher.login
+
+      File.open(FastlyCTL::COOKIE_JAR , 'w+') {|f| f.write(JSON.dump(FastlyCTL::Cookies)) }
+      File.chmod(0600, FastlyCTL::COOKIE_JAR)
+
+      say("Creating root scoped token...")
+
+      if login_results[:user].include?("@fastly.com") && !login_results[:user].include?("+")
+        scope = "root"
+      else
+        scope = "global"
+      end
+
+      o = {
+        user: login_results[:user],
+        pass: login_results[:pass],
+        code: login_results[:code],
+        scope: scope,
+        name: "fastlyctl_token"
+      }
+
+      resp = FastlyCTL::Fetcher.create_token(o)
+
+      token = resp["access_token"]
+      token_id = resp["id"]
+
+      File.open(FastlyCTL::TOKEN_FILE , 'w+') {|f| f.write(token) }
+      File.chmod(0600, FastlyCTL::TOKEN_FILE)
+
+      resp = FastlyCTL::Fetcher.api_request(:get, "/tokens", { headers: {"Fastly-Key" => token}})
+      abort unless resp.count > 0
+
+      resp.each do |t|
+        next unless (t["name"] == "fastlyctl_token" && t["id"] != token_id)
+
+        if yes?("There was already a token created with the name fastlyctl_token. To avoid creating multiple tokens, should it be deleted?")
+          FastlyCTL::Fetcher.api_request(:delete, "/tokens/#{t["id"]}", {headers: {"Fastly-Key" => token}, expected_responses: [204]})
+          say("Token with id #{t["id"]} deleted.")
+        end
+      end
+    end
+  end
+end

data/lib/fastlyctl/commands/open.rb

@@ -0,0 +1,24 @@
+module FastlyCTL
+  class CLI < Thor
+    desc "open DOMAIN", "Find the service ID for a domain and open the Fastly app. You may also specify the service ID or assume the context of the directory you are in by omitting the domain."
+    method_option :service, :aliases => ["--s"]
+    def open(domain=false)
+      if (options[:service] && domain)
+        say("Both domain and service id supplied, using service id.")
+        domain = false
+      end
+
+      if options[:service]
+        id = options[:service]
+      elsif domain
+        id = FastlyCTL::Fetcher.domain_to_service_id(domain)
+      else
+        id = FastlyCTL::Utils.parse_directory
+
+        abort "Could not parse service id from directory. Use the --s <service> flag OR vcl open <domain>." unless id
+      end
+
+      FastlyCTL::Utils.open_service(id)
+    end
+  end
+end

data/lib/fastlyctl/commands/purge_all.rb

@@ -0,0 +1,17 @@
+module FastlyCTL
+  class CLI < Thor
+    desc "purge_all", "Purge all content from a service."
+    method_option :service, :aliases => ["--s"]
+    def purge_all
+      parsed_id = FastlyCTL::Utils.parse_directory
+
+      id = FastlyCTL::Utils.parse_directory
+
+      abort "Could not parse service id from directory. Use --s <service> to specify, vcl download, then try again." unless (id || options[:service])
+
+      FastlyCTL::Fetcher.api_request(:post, "/service/#{id}/purge_all")
+
+      say("Purge all on #{id} completed.")
+    end
+  end
+end

data/lib/fastlyctl/commands/skeleton.rb

@@ -0,0 +1,24 @@
+module FastlyCTL
+  class CLI < Thor
+    desc "skeleton NAME", "Create a skeleton VCL file with the current boilerplate."
+    method_option :service, :aliases => ["--s"]
+    def skeleton(name="main")
+      id = FastlyCTL::Utils.parse_directory unless options[:service]
+      id ||= options[:service]
+      abort "Could not parse service id from directory. Use --s <service> to specify, vcl download, then try again." unless id
+
+      filename = "#{name}.vcl"
+      version = FastlyCTL::Fetcher.get_active_version(id)
+      boilerplate = FastlyCTL::Fetcher.api_request(:get, "/service/#{id}/version/#{version}/boilerplate")
+
+      if (File.exist?(filename))
+        say("#{filename} exists, please delete it if you want this command to overwrite it.")
+        abort
+      end
+
+      File.open(filename , 'w+') {|f| f.write(boilerplate) }
+
+      say("Boilerplate written to #{filename}.")
+    end
+  end
+end