number_station 0.2.0 → 0.4.0

data/lib/number_station/make_onetime_pad.rb

@@ -21,37 +21,72 @@
 require "securerandom"
 require "json"
 require "time"
+require "date"
 
 module NumberStation
-  def self.make_otp(pad_path, length, num_pads)
+  def self.make_otp(pad_path, length, num_pads, agent_name = nil)
     path = pad_path || Dir.pwd
-    len = length || 250
-    num = num_pads || 5
+    len = length || 500
+    num = num_pads || 500
 
-    NumberStation.log.debug "make_otp"
-    pads = {}
-    id = rand(0..99999).to_s.rjust(5, "0")
-    file_name = File.join(path, "one_time_pad_#{id}.json")
-    NumberStation.log.debug "file_name: #{file_name}"
+    # Round length up to nearest multiple of 5
+    len = round_up_to_multiple_of_5(len.to_i)
 
-    0.upto(num.to_i - 1) do |i| 
-      pads[i] = {
-        "key"=>SecureRandom.hex(len.to_i),
-        "epoch_date"=>nil,
-        "consumed"=>false
-      }
+    # Generate date-based filename with uniqueness component
+    date_str = Date.today.strftime("%Y-%m-%d")
+    filename_base = if agent_name && !agent_name.empty?
+                      "#{agent_name}-#{date_str}"
+                    else
+                      "one_time_pad-#{date_str}"
+                    end
+    
+    # Ensure uniqueness: if file exists, add a counter
+    filename = File.join(path, "#{filename_base}.json")
+    counter = 1
+    while File.exist?(filename)
+      filename = File.join(path, "#{filename_base}-#{counter.to_s.rjust(3, '0')}.json")
+      counter += 1
+      # Safety check to prevent infinite loop
+      raise StandardError, "Too many pad files with same date prefix: #{filename_base}" if counter > 999
     end
-    one_time_pads = {
-      :id=> id,
-      :pads=> pads
+    
+    # Generate a unique pad_id for internal use (using epoch timestamp + random)
+    pad_id = generate_pad_id
+
+    pads = generate_pads(num.to_i, len)
+    pad_data = {
+      id: pad_id,
+      pads: pads
     }
 
-    unless File.file?(file_name)
-      f = File.open(file_name, "w")
-      f.write(one_time_pads.to_json)
-      f.close
-    else
-      raise Exception.new("Exception #{file_name} already exists")
+    File.write(filename, pad_data.to_json)
+    NumberStation.log.debug "Created one-time pad: #{filename}"
+    filename
+  end
+
+  private
+
+  def self.round_up_to_multiple_of_5(number)
+    # Round up to nearest multiple of 5
+    # Examples: 3 -> 5, 7 -> 10, 12 -> 15, 15 -> 15, 500 -> 500
+    ((number + 4) / 5) * 5
+  end
+
+  def self.generate_pad_id
+    # Generate a unique ID using epoch timestamp and random component
+    # This ensures uniqueness even if multiple pads are created in the same second
+    "#{Time.now.to_i}-#{rand(1000..9999)}"
+  end
+
+  def self.generate_pads(num_pads, length)
+    pads = {}
+    0.upto(num_pads - 1) do |i|
+      pads[i] = {
+        "key" => SecureRandom.hex(length),
+        "epoch_date" => nil,
+        "consumed" => false
+      }
     end
+    pads
   end
 end

data/lib/number_station/phonetic_conversion.rb

@@ -21,7 +21,7 @@
 
 module NumberStation
 
-  ALPHABET ={
+  ALPHABET = {
     '0' => "zero",
     '1' => "one",
     '2' => "two",
@@ -58,80 +58,69 @@ module NumberStation
     'x' => "xray",
     'y' => "yankee",
     'z' => "zulu"
-  }
+  }.freeze
 
-
-  def self.lookup_phonetic(c)
-    begin
-      return NumberStation::ALPHABET[c] + ' ' || ' '
-    rescue Exception => e
-      return ' '
-    end
+  def self.lookup_phonetic(char)
+    phonetic = ALPHABET[char.downcase]
+    phonetic ? phonetic : nil
   end
 
 
   def self.espeak_word_template(word)
-    return "<prosody pitch=\"#{randomsign() + rand(0..200).to_s}\">#{word}</prosody>"
+    pitch = "#{random_sign}#{rand(0..200)}"
+    "<prosody pitch=\"#{pitch}\">#{word}</prosody>"
   end
 
-
-  def self.randomsign()
-    return rand(0..1) == 0 ? "-" : "+"
+  def self.random_sign
+    rand(0..1) == 0 ? "-" : "+"
   end
 
-
   def self.generate_sentence(message)
-    sentence = ""
-    message.split(" ").each {|i| sentence += espeak_word_template(i)}
-    return "<speak version=\"1.0\" xmlns=\"\" xmlns:xsi=\"\" xsi:schemaLocation=\"\" xml:lang=\"\"><voice gender=\"female\">#{sentence}</voice></speak>"
+    words = message.split(" ")
+    prosody_words = words.map { |word| espeak_word_template(word) }.join
+    "<speak version=\"1.0\" xmlns=\"\" xmlns:xsi=\"\" xsi:schemaLocation=\"\" xml:lang=\"\"><voice gender=\"female\">#{prosody_words}</voice></speak>"
   end
 
-
   def self.write_espeak_template_file(filename, sentence)
-    f = File.open(filename, "w")
-    f.write(sentence)
-    f.close
+    File.write(filename, sentence)
   end
 
 
   def self.call_espeak(input_file_path, output_file_path)
-    if NumberStation.data["resources"]["espeak"]["glados"]
-      cmd = "espeak -ven+f3 -m -p 60 -s 180 -f #{input_file_path} --stdout | ffmpeg -i - -ar 44100 -ac 2 -ab 192k -f mp3 #{output_file_path}"
-    else
-      cmd = "espeak -m -p 60 -s 180 -f #{input_file_path} --stdout | ffmpeg -i - -ar 44100 -ac 2 -ab 192k -f mp3 #{output_file_path}"
-    end
-
-    unless NumberStation.command?('espeak') || NumberStation.command?('ffmpeg')
+    unless NumberStation.command?('espeak') && NumberStation.command?('ffmpeg')
       NumberStation.log.error "number_station requires the espeak and ffmpeg utilities are installed in order to output an mp3 file."
-    else
-      `#{cmd}`
+      return
     end
-  end
 
+    # Use GLaDOS voice settings by default
+    voice_flag = "-ven+f3"
+    cmd = "espeak #{voice_flag} -m -p 60 -s 180 -f #{input_file_path} --stdout | ffmpeg -i - -ar 44100 -ac 2 -ab 192k -f mp3 #{output_file_path}"
+    `#{cmd}`
+  end
 
   def self.write_mp3(message, output_file_path)
-    filename = NumberStation.data["resources"]["espeak"]["sentence_template"]
-    if NumberStation.data["resources"]["espeak"]["glados"]
-      sentence = NumberStation.generate_sentence(message)
-    else
-      sentence = message
-    end
-    NumberStation.write_espeak_template_file(filename, sentence)
-    NumberStation.call_espeak(filename, output_file_path)
+    # Use temporary file for espeak template
+    template_file = "/tmp/espeak_tmp.xml"
+    # Generate GLaDOS-style sentence
+    sentence = generate_sentence(message)
+    
+    write_espeak_template_file(template_file, sentence)
+    call_espeak(template_file, output_file_path)
   end
 
-
   def self.to_phonetic(file_name)
-    message = ''
-    puts file_name
-    f = File.open(file_name)
-    raw_message = f.read()
-    f.close()
-
-    raw_message.each_char do |c|
-      message += NumberStation.lookup_phonetic(c)
+    raw_message = File.read(file_name)
+    # Remove all whitespace from input
+    cleaned_message = raw_message.gsub(/[\s\n\r]/, '')
+    
+    # Process in groups of 5 characters
+    groups = cleaned_message.chars.each_slice(5).map do |group|
+      # Convert each character in the group to phonetic
+      group.map { |char| lookup_phonetic(char) }.compact.join(' ')
     end
-    return message
+    
+    # Join groups with double space for readability
+    groups.join('  ')
   end
 
 

data/lib/number_station/version.rb

@@ -20,5 +20,5 @@
 =end
 
 module NumberStation
-  VERSION = "0.2.0"
+  VERSION = "0.4.0"
 end

data/lib/number_station.rb

@@ -18,7 +18,6 @@
     You should have received a copy of the GNU General Public License
     along with this program.  If not, see <https://www.gnu.org/licenses/>.
 =end
-require 'pastel'
 require 'json'
 require 'logger'
 require 'number_station/cli'
@@ -27,11 +26,12 @@ require 'number_station/encrypt_message'
 require 'number_station/decrypt_message'
 require 'number_station/make_onetime_pad'
 require 'number_station/phonetic_conversion'
+require 'number_station/examine_pads'
+require 'number_station/GLaDOS_espeak'
 require 'number_station/version'
 
 
 module NumberStation
-
   def self.command?(name)
     `which #{name}`
     $?.success?
@@ -41,16 +41,46 @@ module NumberStation
     @log = log
   end
 
-  def self.log()
-    return @log
+  def self.log
+    @log
   end
 
   def self.set_data(data)
     @data = data
   end
 
-  def self.data()
-    return @data
+  def self.data
+    @data
+  end
+
+  def self.agent_list
+    return [] unless @data && @data["agent_list"]
+    
+    # Handle backward compatibility: if agent_list contains strings, convert them
+    agents = @data["agent_list"]
+    if agents.is_a?(Array) && agents.first.is_a?(String)
+      # Old format: array of strings, convert to hashes
+      agents.map do |name|
+        {
+          "name" => name,
+          "location" => nil,
+          "handler_codeword" => nil,
+          "start_date" => nil,
+          "end_date" => nil,
+          "active" => false
+        }
+      end
+    else
+      # New format: array of hashes
+      agents
+    end
   end
 
+  def self.find_agent_by_name(name)
+    agent_list.find { |agent| agent["name"] == name }
+  end
+
+  def self.active_agents
+    agent_list.select { |agent| agent["active"] == true }
+  end
 end

data/number_station.gemspec

@@ -53,8 +53,8 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "pastel"
-  spec.add_dependency "thor"
+  spec.add_dependency "thor", "~> 1.5"
 
-  spec.add_development_dependency "rake"
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 13.0"
 end