qcmd 0.1.7 → 0.1.8

data/README.md

@@ -13,7 +13,12 @@ IT.**
 
 ## Installation
 
-Install this gem to your machine by running the following command:
+Before installing qcmd, you'll have to install the [Command Line Tools for
+Xcode](https://developer.apple.com/downloads). They're free, but you'll need an
+Apple ID to download them.
+
+Once you've done that, you can install qcmd to your machine by running the
+following command:
 
     $ sudo gem install qcmd
 
@@ -33,7 +38,7 @@ send commands to cues and the workspace.
 wondering what you can do from the console.
 
 Run `qcmd` with the -v option to get full debugging output. Use the main
-project repository (https://github.com/abachman/qcmd) to report any issues.
+project repository (https://github.com/Figure53/qcmd) to report any issues.
 
 An example session might look like this:
 

data/TODO.md

@@ -0,0 +1,31 @@
+### copyable fields
+
+* sliderLevels
+* fade shape
+* action
+* preWait
+* postWait
+* AU status?
+* geometry
+* full matrix
+
+
+### aliases and composable actions
+
+`alias n (cue $1 name $2)` creates a new command, "n" that can be called just
+like any built in command.  `n 20 "Basic Intro"` expands into `cue 20 name "Basic Intro"`.
+
+All actions should have a return value, then we can nest commands to create new
+actions:
+
+`alias copy-name (cue $2 name (cue $1 name))`
+
+The **$** argument operator can be included in double quoted strings to act as
+a simple templating tool. For example: `alias act-scene (cue $1 name "Act $2: Scene $3")`
+could be used to give cues a specifc name with some plugged-in values. Now using
+`act-scene 20 1 2` would give cue number 20 the name "Act 1: Scene 2".
+
+Because custom actions expand into qcmd's normal actions, wildcards should work
+fine. `act-scene 20.* 1 2` would change the name of every cue whose number
+starts with "20." to "Act 1: Scene 2".
+

data/bin/qcmd

@@ -10,7 +10,6 @@ opts = Trollop::options do
   opt :verbose, 'Use verbose mode', :default => false
   opt :debug, "Show full debug output, don't make changes to workspaces", :default => false
   opt :machine, "Automatically try to connect to the machine with the given name", :type => :string
-  opt :machine_passcode, "Use the given machine passcode", :type => :integer
   opt :workspace, "Automatically try to connect to the workspace with the given name", :type => :string
   opt :workspace_passcode, "Use the given workspace passcode", :type => :integer
   opt :command, "Execute a single command and exit", :type => :string
@@ -27,6 +26,8 @@ end
 
 # browse local network and check for qlab + qlab workspaces
 
+Qcmd::History.load
+
 if !opts[:machine_given]
   Qcmd.ascii_qlab
   Qcmd.print

data/lib/qcmd.rb

@@ -1,17 +1,21 @@
+# communicate!
 require 'socket'
 require 'osc-ruby'
 
-require 'qcmd/version'
+# data from QLab
+require 'json'
 
+require 'qcmd/version'
 require 'qcmd/plaintext'
 require 'qcmd/commands'
 require 'qcmd/input_completer'
-
 require 'qcmd/core_ext/array'
 require 'qcmd/core_ext/osc/message'
-require 'qcmd/core_ext/osc/stopping_server'
+require 'qcmd/core_ext/osc/tcp_client'
 
 module Qcmd
+  autoload :Configuration, 'qcmd/configuration'
+  autoload :History, 'qcmd/history'
   autoload :Handler, 'qcmd/handler'
   autoload :Server, 'qcmd/server'
   autoload :Context, 'qcmd/context'
@@ -21,6 +25,10 @@ module Qcmd
   autoload :Network, 'qcmd/network'
   autoload :QLab, 'qcmd/qlab'
   autoload :VERSION, 'qcmd/version'
+  autoload :Action, 'qcmd/action'
+  autoload :Aliases, 'qcmd/aliases'
+
+  # on launch
 
   class << self
     include Qcmd::Plaintext
@@ -61,6 +69,10 @@ module Qcmd
     end
 
     def debug message
+      # always write to log
+
+      Qcmd::Configuration.log.puts "[%s] %s" % [Time.now.strftime('%T'), message]
+
       log(message) if log_level == :debug
     end
 

data/lib/qcmd/action.rb

@@ -0,0 +1,160 @@
+module Qcmd
+  class Action
+    attr_reader :code
+
+    # initialize and evaluate in one shot
+    def self.evaluate action_input
+      is_cue_action = false
+
+      if action_input.is_a?(String)
+        is_cue_action = %w(cue cue_id).include?(action_input.split.first)
+      else
+        is_cue_action = ['cue', 'cue_id', :cue, :cue_id].include?(action_input.first)
+      end
+
+      if is_cue_action
+        CueAction.new(action_input).evaluate
+      else
+        Action.new(action_input).evaluate
+      end
+    end
+
+    def initialize(expression)
+      if expression.is_a?(String)
+        expression = Qcmd::Parser.parse(expression)
+      end
+
+      @code = parse(expression)
+    end
+
+    def evaluate
+      if code.size == 0
+        nil
+      else
+        @code = code.map do |token|
+          if token.is_a?(Action)
+            Qcmd.debug "[Action evaluate] evaluating nested action: #{ token.code.inspect }"
+            token.evaluate
+          else
+            token
+          end
+        end
+
+        Qcmd.debug "[Action evaluate] evaluating code: #{ code.inspect }"
+
+        send_message
+      end
+    end
+
+    def parse(expression)
+      # unwrap nested arrays
+      if expression.size == 1 && expression[0].is_a?(Array)
+        expression = expression[0]
+      end
+
+      expression.map do |token|
+        if token.is_a?(Array)
+          if [:cue, :cue_id].include?(token.first)
+            Qcmd.debug "nested cue action detected in #{ expression.inspect }"
+            CueAction.new(token)
+          else
+            Action.new(token)
+          end
+        else
+          token
+        end
+      end.tap {|exp|
+        Qcmd.debug "[Action parse] returning: #{ exp.inspect }"
+      }
+    end
+
+    # the default command builder
+    def osc_message
+      OSC::Message.new osc_address.to_s, *osc_arguments
+    end
+
+    def osc_address
+      # prefix w/ slash if necessary
+      if %r[^/] !~ code[0].to_s
+        "/#{ code[0] }"
+      else
+        code[0]
+      end
+    end
+
+    def osc_address=(value)
+      code[0] = value
+    end
+
+    def osc_arguments
+      code[1..-1]
+    end
+
+    # the raw command
+    def command
+      code[0]
+    end
+
+    private
+
+    def send_message
+      responses = []
+
+      Qcmd.context.qlab.send(osc_message) do |response|
+        # puts "response to: #{ osc_message.inspect }"
+        # puts response.inspect
+
+        responses << QLab::Reply.new(response)
+      end
+
+      if responses.size == 1
+        q_reply = responses[0]
+        Qcmd.debug "[Action send_message] got one response: #{q_reply.inspect}"
+
+        if q_reply.has_data?
+          q_reply.data
+        else
+          q_reply
+        end
+      else
+        responses
+      end
+    end
+  end
+
+  class CueAction < Action
+    # cue commands work differently
+    def command
+      code[2]
+    end
+
+    def osc_address
+      "/#{ code[0] }/#{ code[1] }/#{ code[2] }"
+    end
+
+    def osc_arguments
+      args = code[3..-1]
+      if args.nil?
+        nil
+      else
+        args.map {|arg|
+          if arg.is_a?(Symbol)
+            arg.to_s
+          else
+            arg
+          end
+        }
+      end
+    end
+
+    # cue specific fields
+
+    def id_field
+      code[0]
+    end
+
+    def identifier
+      code[1]
+    end
+  end
+end

data/lib/qcmd/aliases.rb

@@ -0,0 +1,25 @@
+module Qcmd
+  class Aliases
+    def self.defaults
+      @defaults ||= {
+        'n' => 'cue $1 name $2',
+        # zero-out cue_number
+        'zero-out' => (1..48).map {|n| "(cue $1 sliderLevel #{n} 0)"}.join(' '),
+        # copy-sliders from_cue_number to_cue_number
+        'copy-sliders' => (1..48).map {|n| "(cue $2 sliderLevel #{n} (cue $1 sliderLevel #{n} 0))"}.join(' ')
+      }.merge(copy_cue_actions)
+    end
+
+    def self.copy_cue_actions
+      Hash[
+        %w(name notes fileTarget cueTargetNumber cueTargetId preWait duration
+           postWait continueMode flagged armed colorName).map do |field|
+          [
+            "copy-#{ field }",
+            "(cue $2 #{ field } (cue $1 #{ field }))"
+          ]
+        end
+      ]
+    end
+  end
+end

data/lib/qcmd/cli.rb

@@ -1,124 +1,304 @@
-require 'qcmd/server'
-
 require 'readline'
-
 require 'osc-ruby'
 
 module Qcmd
   class CLI
     include Qcmd::Plaintext
 
-    attr_accessor :server, :prompt
+    attr_accessor :prompt
 
     def self.launch options={}
       new options
     end
 
     def initialize options={}
-      Qcmd.debug "(launching with options: #{options.inspect})"
-      # start local listening port
-      Qcmd.context = Qcmd::Context.new
+      Qcmd.debug "[CLI initialize] launching with options: #{options.inspect}"
 
-      self.prompt = '> '
+      Qcmd.context = Qcmd::Context.new
 
       if options[:machine_given]
-        Qcmd.debug "(autoconnecting to #{ options[:machine] })"
+        Qcmd.debug "[CLI initialize] autoconnecting to machine #{ options[:machine] }"
 
         Qcmd.while_quiet do
-          connect_to_machine_by_name options[:machine], options[:machine_passcode]
+          connect_to_machine_by_name(options[:machine])
         end
 
         if options[:workspace_given]
+          Qcmd.debug "[CLI initialize] autoconnecting to workspace #{ options[:machine] }"
+
           Qcmd.while_quiet do
-            connect_to_workspace_by_name options[:workspace], options[:workspace_passcode]
+            connect_to_workspace_by_name(options[:workspace], options[:workspace_passcode])
           end
 
           if options[:command_given]
-            handle_message options[:command]
+            handle_input options[:command]
             print %[sent command "#{ options[:command] }"]
             exit 0
           end
+        elsif Qcmd.context.machine.workspaces.size == 1 &&
+              !Qcmd.context.machine.workspaces.first.passcode? &&
+              !Qcmd.context.workspace_connected?
+          connect_to_workspace_by_index(0, nil)
         end
       end
 
+      # add aliases to input completer
+      InputCompleter.add_commands aliases.keys
+
       start
     end
 
-    def connect machine, passcode
+    def machine
+      Qcmd.context.machine
+    end
+
+    def reset
+      Qcmd.context.reset
+    end
+
+    def aliases
+      @aliases ||= Qcmd::Aliases.defaults.merge(Qcmd::Configuration.config['aliases'])
+    end
+
+    def alias_arg_matcher
+      /\$(\d+)/
+    end
+
+    def add_alias name, expression
+      aliases[name] = Parser.generate(expression)
+      InputCompleter.add_command name
+      Qcmd::Configuration.update('aliases', aliases)
+
+      aliases[name]
+    end
+
+    def replace_args alias_expression, original_expression
+      Qcmd.debug "[CLI replace_args] populating #{ alias_expression.inspect } with #{ original_expression.inspect }"
+
+      alias_expression.map do |arg|
+        if arg.is_a?(Array)
+          replace_args(arg, original_expression)
+        elsif (arg.is_a?(Symbol) || arg.is_a?(String)) && alias_arg_matcher =~ arg.to_s
+          while alias_arg_matcher  =~ arg.to_s
+            arg_idx = $1.to_i
+            arg_val = original_expression[arg_idx]
+
+            Qcmd.debug "[CLI replace_args] found $#{ arg_idx }, replacing with #{ arg_val.inspect }"
+
+            arg = arg.to_s.sub("$#{ arg_idx }", arg_val.to_s)
+          end
+
+          arg
+        else
+          arg
+        end
+      end
+    end
+
+    def expand_alias key, expression
+      Qcmd.debug "[CLI expand_alias] using alias of #{ key } with #{ expression.inspect }"
+
+      new_command = aliases[key]
+
+      # observe alias arity
+      argument_placeholders = new_command.scan(alias_arg_matcher).uniq.map {|placeholder|
+        placeholder[0].sub(/$\$/, '').to_i
+      }
+
+      if argument_placeholders.size > 0
+        arguments_expected = argument_placeholders.max
+
+        # because expression is alias + arguments, the expression's size should
+        # be at least arguments_expected + 1
+        if expression.size <= arguments_expected
+          print "This custom command expects at least #{ arguments_expected } arguments."
+          return
+        end
+      end
+
+      new_command = Parser.parse(new_command)
+      new_command = replace_args(new_command, expression)
+
+      new_command
+    end
+
+    def get_prompt
+      clock = Time.now.strftime "%H:%M"
+      prefix = []
+
+      if Qcmd.context.machine_connected?
+        prefix << "[#{ Qcmd.context.machine.name }]"
+      end
+
+      if Qcmd.context.workspace_connected?
+        prefix << "[#{ Qcmd.context.workspace.name }]"
+      end
+
+      if Qcmd.context.cue_connected?
+        prefix << "[#{ Qcmd.context.cue.number } #{ Qcmd.context.cue.name }]"
+      end
+
+      ["#{clock} #{prefix.join(' ')}", "> "]
+    end
+
+    def connect machine
       if machine.nil?
         print "A valid machine is needed to connect!"
         return
       end
 
+      reset
+
       Qcmd.context.machine = machine
-      Qcmd.context.workspace = nil
 
-      if server.nil?
-        # set client connection and start listening port
-        self.server = Qcmd::Server.new :receive => 53001
-      else
-        # change client connection
-        server.connect_to_client
+      # in case this is a reconnection
+      Qcmd.context.connect_to_qlab
+
+      # tell QLab to always reply to messages
+      response = Qcmd::Action.evaluate('/alwaysReply 1')
+      if response.nil? || response.empty?
+        print %[Failed to connect to QLab machine "#{ machine.name }"]
+      elsif response.status == 'ok'
+        print %[Connected to machine "#{ machine.name }"]
       end
-      server.run
 
-      server.load_workspaces
+      machine.workspaces = Qcmd::Action.evaluate('workspaces').map {|ws| QLab::Workspace.new(ws)}
+
+      if Qcmd.context.machine.workspaces.size == 1 && !Qcmd.context.machine.workspaces.first.passcode?
+        connect_to_workspace_by_index(0, nil)
+      else
+        Handler.print_workspace_list
+      end
+    end
 
-      self.prompt = "#{ machine.name }> "
+    def disconnected_machine_warning
+      if Qcmd::Network.names.size > 0
+        print "Try one of the following:"
+        Qcmd::Network.names.each do |name|
+          print %[  #{ name }]
+        end
+      else
+        print "There are no QLab machines on this network :("
+      end
     end
 
-    def connect_to_machine_by_name machine_name, passcode
+    def connect_to_machine_by_name machine_name
       if machine = Qcmd::Network.find(machine_name)
-        print "connecting to machine: #{machine_name}"
-        connect machine, passcode
+        print "Connecting to machine: #{machine_name}"
+        connect machine
+      else
+        print 'Sorry, that machine could not be found'
+      end
+    end
+
+    def connect_to_machine_by_index machine_idx
+      if machine = Qcmd::Network.find_by_index(machine_idx)
+        print "Connecting to machine: #{machine.name}"
+        connect machine
       else
-        print 'sorry, that machine could not be found'
+        print 'Sorry, that machine could not be found'
+      end
+    end
+
+    def connect_to_workspace_by_index workspace_idx, passcode
+      if Qcmd.context.machine_connected?
+        if workspace = Qcmd.context.machine.workspaces[workspace_idx]
+          connect_to_workspace_by_name workspace.name, passcode
+        else
+          print "That workspace isn't on the list."
+        end
+      else
+        print %[You can't connect to a workspace until you've connected to a machine. ]
+        disconnected_machine_warning
       end
     end
 
     def connect_to_workspace_by_name workspace_name, passcode
-      if workspace = Qcmd.context.machine.find_workspace(workspace_name)
-        workspace.passcode = passcode
-        print "connecting to workspace: #{workspace_name}"
-        use_workspace workspace
+      if Qcmd.context.machine_connected?
+        if workspace = Qcmd.context.machine.find_workspace(workspace_name)
+          workspace.passcode = passcode
+          print "Connecting to workspace: #{workspace_name}"
+
+          use_workspace workspace
+        else
+          print "That workspace doesn't seem to exist, try one of the following:"
+          Qcmd.context.machine.workspaces.each do |ws|
+            print %[  "#{ ws.name }"]
+          end
+        end
+      else
+        print %[You can't connect to a workspace until you've connected to a machine. ]
+        disconnected_machine_warning
       end
     end
 
     def use_workspace workspace
-      Qcmd.debug %[(connecting to workspace: "#{workspace.name}")]
+      Qcmd.debug %[[CLI use_workspace] connecting to workspace: "#{workspace.name}"]
+
       # set workspace in context. Will unset later if there's a problem.
       Qcmd.context.workspace = workspace
 
-      server.connect_to_workspace workspace
-      if Qcmd.context.workspace_connected? && Qcmd.context.workspace.cues
-        print "loaded #{pluralize Qcmd.context.workspace.cues.size, 'cue'}"
-        self.prompt = "#{ Qcmd.context.machine.name }:#{ workspace.name }> "
+      # send connect message to QLab to make sure subsequent messages target it
+      if workspace.passcode?
+        ws_action_string = "workspace/#{workspace.id}/connect %04i" % workspace.passcode
+      else
+        ws_action_string = "workspace/#{workspace.id}/connect"
       end
-    end
 
-    def reset
-      Qcmd.context.reset
-      server.stop
-      self.prompt = "> "
+      reply = Qcmd::Action.evaluate(ws_action_string)
+
+      if reply == 'badpass'
+        print 'Failed to connect to workspace, bad passcode or no passcode given.'
+        Qcmd.context.disconnect_workspace
+      elsif reply == 'ok'
+        print %[Connected to "#{Qcmd.context.workspace.name}"]
+        Qcmd.context.workspace_connected = true
+      end
+
+      # if it worked, load cues automatically
+      if Qcmd.context.workspace_connected?
+        load_cues
+
+        if Qcmd.context.workspace.cue_lists
+          print "Loaded #{pluralize Qcmd.context.workspace.cues.size, 'cue'}"
+        end
+      end
     end
 
     def start
       loop do
         # blocks the whole Ruby VM
-        message = Readline.readline(prompt, true)
+        prefix, char = get_prompt
+
+        Qcmd.print prefix
+        cli_input = Readline.readline(char, true)
 
-        if message.nil? || message.size == 0
-          Qcmd.debug "(got: #{ message.inspect })"
+        if cli_input.nil? || cli_input.size == 0
+          Qcmd.debug "[CLI start] got: #{ cli_input.inspect }"
           next
         end
 
-        handle_message(message)
+        # save all commands to log
+        Qcmd::History.push(cli_input)
+
+        begin
+          if /;/ =~ cli_input
+            cli_input.split(';').each do |sub_input|
+              handle_input Qcmd::Parser.parse(sub_input)
+            end
+          else
+            handle_input Qcmd::Parser.parse(cli_input)
+          end
+        rescue => ex
+          print "Command parser couldn't handle the last command: #{ ex.message }"
+          print ex.backtrace
+        end
       end
     end
 
-    def handle_message message
-      args    = Qcmd::Parser.parse(message)
-      command = args.shift
+    # the actual command line interface interactor
+    def handle_input args
+      command = args[0].to_s
 
       case command
       when 'exit', 'quit', 'q'
@@ -126,125 +306,340 @@ module Qcmd
         exit 0
 
       when 'connect'
-        Qcmd.debug "(connect command received args: #{ args.inspect })"
+        Qcmd.debug "[CLI handle_input] connect command received args: #{ args.inspect } :: #{ args.map {|a| a.class.to_s}.inspect}"
 
-        machine_name = args.shift
-        passcode     = args.shift
+        machine_ident = args[1]
 
-        connect_to_machine_by_name machine_name, passcode
+        if machine_ident.is_a?(Fixnum)
+          # machine "index" will be given with a 1-indexed value instead of the
+          # stored 0-indexed value.
+          connect_to_machine_by_index machine_ident - 1
+        else
+          connect_to_machine_by_name machine_ident
+        end
 
       when 'disconnect'
-        reset
-        Qcmd::Network.browse_and_display
+        disconnect_what = args[1]
+
+        if disconnect_what == 'workspace'
+          Qcmd.context.disconnect_cue
+          Qcmd.context.disconnect_workspace
+
+          Handler.print_workspace_list
+        elsif disconnect_what == 'cue'
+          Qcmd.context.disconnect_cue
+        else
+          reset
+          Qcmd::Network.browse_and_display
+        end
+
+      when '..'
+        if Qcmd.context.cue_connected?
+          Qcmd.context.disconnect_cue
+        elsif Qcmd.context.workspace_connected?
+          Qcmd.context.disconnect_workspace
+        else
+          reset
+        end
 
       when 'use'
-        Qcmd.debug "(use command received args: #{ args.inspect })"
+        Qcmd.debug "[CLI handle_input] use command received args: #{ args.inspect }"
 
-        workspace_name = args.shift
-        passcode       = args.shift
+        workspace_name = args[1]
+        passcode       = args[2]
 
-        Qcmd.debug "(using workspace: #{ workspace_name.inspect })"
+        Qcmd.debug "[CLI handle_input] using workspace: #{ workspace_name.inspect }"
 
         if workspace_name
-          connect_to_workspace_by_name workspace_name, passcode
+          if workspace_name.is_a?(Fixnum)
+            # decrement given idx
+            connect_to_workspace_by_index workspace_name - 1, passcode
+          else
+            connect_to_workspace_by_name workspace_name, passcode
+          end
         else
           print "No workspace name given. The following workspaces are available:"
-          Qcmd.context.print_workspace_list
+          Handler.print_workspace_list
+        end
+
+      when 'workspaces'
+        if !Qcmd.context.machine_connected?
+          disconnected_machine_warning
+        else
+          machine.workspaces = Qcmd::Action.evaluate(args).map {|ws| QLab::Workspace.new(ws)}
+          Handler.print_workspace_list
+        end
+
+      when 'workspace'
+        workspace_command = args[1]
+
+        if !Qcmd.context.workspace_connected?
+          handle_failed_workspace_command cli_input
+          return
+        end
+
+        if workspace_command.nil?
+          print_wrapped("no workspace command given. available workspace commands
+                         are: #{Qcmd::InputCompleter::ReservedWorkspaceWords.join(', ')}")
+        else
+          send_workspace_command(workspace_command, *args)
         end
 
       when 'help'
         help_command = args.shift
 
         if help_command.nil?
-          Qcmd::Commands::Help.print_all_commands
           # print help according to current context
+          Qcmd::Commands::Help.print_all_commands
         else
           # print command specific help
         end
 
       when 'cues'
         if !Qcmd.context.workspace_connected?
-          failed_workspace_command message
+          handle_failed_workspace_command cli_input
           return
         end
 
         # reload cues
-        server.load_cues
+        load_cues
 
-        print
-        print centered_text(" Cues ", '-')
-        table ['Number', 'Id', 'Name', 'Type'], Qcmd.context.workspace.cues.map {|cue|
-          [cue.number, cue.id, cue.name, cue.type]
-        }
-        print
+        Qcmd.context.workspace.cue_lists.each do |cue_list|
+          print
+          print centered_text(" Cues: #{ cue_list.name } ", '-')
+          printable_cues = []
+
+          add_cues_to_list cue_list, printable_cues, 0
+
+          table ['Number', 'Id', 'Name', 'Type'], printable_cues
+
+          print
+        end
+
+      when /^(cue|cue_id)$/
+        # id_field = $1
 
-      when 'cue', 'c'
         if !Qcmd.context.workspace_connected?
-          failed_workspace_command message
+          handle_failed_workspace_command cli_input
           return
         end
 
-        # pull off cue number
-        cue_number = args.shift
-        cue_action = args.shift
-
-        if cue_number.nil?
-          print "no cue command given. cue commands should be in the form:"
+        if args.size < 3
+          print "Cue commands should be in the form:"
           print
-          print "  > cue NUMBER COMMAND ARGUMENTS"
+          print "  > cue NUMBER COMMAND [ARGUMENTS]"
           print
-          print_wrapped("available cue commands are: #{Qcmd::Commands::ALL_CUE_COMMANDS.join(', ')}")
-        elsif cue_action.nil?
-          server.send_workspace_command("cue/#{ cue_number }")
-        else
-          server.send_cue_command(cue_number, cue_action, *args)
+          print "or"
+          print
+          print "  > cue_id ID COMMAND [ARGUMENTS]"
+          print
+          print_wrapped("available cue commands are: #{Qcmd::Commands::CUE.join(', ')}")
+          print
+          return
         end
 
-      when 'workspaces'
-        if !Qcmd.context.machine_connected?
-          print 'cannot load workspaces until you are connected to a machine'
-          return
+        cue_action = Qcmd::CueAction.new(args)
+
+        reply = cue_action.evaluate
+
+        if reply.is_a?(QLab::Reply)
+          if !reply.status.nil?
+            print reply.status
+          end
+        else
+          render_data reply
         end
 
-        server.load_workspaces
+        # fixate on cue
+        if Qcmd.context.workspace.has_cues?
+          _cue = Qcmd.context.workspace.cues.find {|cue|
+            case cue_action.id_field
+            when :cue
+              cue.number.to_s == cue_action.identifier.to_s
+            when :cue_id
+              cue.id.to_s == cue_action.identifier.to_s
+            end
+          }
 
-      when 'workspace'
-        workspace_command = args.shift
+          if _cue
+            Qcmd.context.cue = _cue
+            Qcmd.context.cue_connected = true
 
-        if !Qcmd.context.workspace_connected?
-          handle_failed_workspace_command message
-          return
+            Qcmd.context.cue.sync
+          end
         end
 
-        if workspace_command.nil?
-          print_wrapped("no workspace command given. available workspace commands
-                         are: #{Qcmd::InputCompleter::ReservedWorkspaceWords.join(', ')}")
-        else
-          server.send_workspace_command(workspace_command, *args)
+      when 'aliases'
+        print centered_text(" Available Custom Commands ", '-')
+        print
+
+        aliases.each do |(key, val)|
+          print key
+          print '    ' + word_wrap(val, :indent => '    ', :preserve_whitespace => true).join("\n")
+          print
         end
 
+      when 'alias'
+        new_alias = add_alias(args[1].to_s, args[2])
+        print %[Added alias for "#{ args[1] }": #{ new_alias }]
+
       else
-        if Qcmd.context.workspace_connected?
-          if Qcmd::InputCompleter::ReservedWorkspaceWords.include?(command)
-            server.send_workspace_command(command, *args)
+        if aliases[command]
+          Qcmd.debug "[CLI handle_input] using alias #{ command }"
+
+          new_expression = expand_alias(command, args)
+
+          # alias expansion failed, go back to CLI
+          return if new_expression.nil?
+
+          Qcmd.debug "[CLI handle_input] expanded to: #{ new_expression.inspect }"
+
+          # recurse!
+          if new_expression.size == 1 && new_expression[0].is_a?(Array)
+            while new_expression.size == 1 && new_expression[0].is_a?(Array)
+              new_expression = new_expression[0]
+            end
+          end
+
+          if new_expression.all? {|exp| exp.is_a?(Array)}
+            new_expression.each {|nested_expression|
+              handle_input nested_expression
+            }
           else
-            if %r[/] =~ command
-              # might be legit OSC command, try sending
-              server.send_command(command, *args)
-            else
-              print "unrecognized command: #{ command }"
+            handle_input(new_expression)
+          end
+
+
+        elsif Qcmd.context.cue_connected? && Qcmd::InputCompleter::ReservedCueWords.include?(command)
+          # prepend the given command with a cue address
+          if Qcmd.context.cue.number.nil? || Qcmd.context.cue.number.size == 0
+            command = "cue_id/#{ Qcmd.context.cue.id }/#{ command }"
+          else
+            command = "cue/#{ Qcmd.context.cue.number }/#{ command }"
+          end
+
+          args = [command].push(*args[1..-1])
+
+          cue_action = Qcmd::CueAction.new(args)
+
+          reply = cue_action.evaluate
+
+          if reply.is_a?(QLab::Reply)
+            if !reply.status.nil?
+              print reply.status
             end
+          else
+            render_data reply
           end
+
+          # send_workspace_command(command, *args)
+        elsif Qcmd.context.workspace_connected? && Qcmd::InputCompleter::ReservedWorkspaceWords.include?(command)
+          send_workspace_command(command, *args)
+
         else
-          handle_failed_workspace_command message
+          # failure modes?
+          if %r[/] =~ command
+            # might be legit OSC command, try sending
+            reply = Qcmd::Action.evaluate(args)
+            if reply.is_a?(QLab::Reply)
+              if !reply.status.nil?
+                print reply.status
+              end
+            else
+              render_data reply
+            end
+          else
+            if Qcmd.context.cue_connected?
+              # cue is connected, but command isn't a valid cue command
+              print_wrapped("Unrecognized command: '#{ command }'. Try one of these cue commands: #{ Qcmd::InputCompleter::ReservedCueWords.join(', ') }")
+              print 'or disconnect from the cue with ..'
+            elsif Qcmd.context.workspace_connected?
+              # workspace is connected, but command isn't a valid workspace command
+              print_wrapped("Unrecognized command: '#{ command }'. Try one of these workspace commands: #{ Qcmd::InputCompleter::ReservedWorkspaceWords.join(', ') }")
+            elsif Qcmd.context.machine_connected?
+              send_command(command, *args)
+            else
+              print 'you must connect to a machine before sending commands'
+            end
+          end
         end
       end
     end
 
     def handle_failed_workspace_command command
-      print_wrapped(%[the command, "#{ command }" can't be processed yet. you must
+      print_wrapped(%[The command, "#{ command }" can't be processed yet. you must
                       first connect to a machine and a workspace
                       before issuing other commands.])
     end
+
+    def add_cues_to_list cue, list, level
+      cue.cues.each {|_c|
+        name = _c.name
+
+        if level > 0
+          name += " " + ("-" * level) + "|"
+        end
+
+        list << [_c.number, _c.id, name, _c.type]
+        add_cues_to_list(_c, list, level + 1) if _c.has_cues?
+      }
+    end
+
+    ### communication actions
+    private
+
+    def render_data data
+      if data.is_a?(Array) || data.is_a?(Hash)
+        begin
+          print JSON.pretty_generate(data)
+        rescue JSON::GeneratorError
+          Qcmd.debug "[CLI render_data] failed to JSON parse data: #{ data.inspect }"
+          print data.to_s
+        end
+      else
+        print data.to_s
+      end
+    end
+
+
+    def send_command command, *args
+      options = args.extract_options!
+
+      Qcmd.debug "[CLI send_command] building command from command, args, options: #{ command.inspect }, #{ args.inspect }, #{ options.inspect }"
+
+      # make sure command is valid OSC Address
+      if %r[^/] =~ command
+        address = command
+      else
+        address = "/#{ command }"
+      end
+
+      osc_message = OSC::Message.new address, *args
+
+      Qcmd.debug "[CLI send_command] sending osc message #{ osc_message.address } #{osc_message.has_arguments? ? 'with' : 'without'} args"
+
+      if block_given?
+        # use given response handler, pass it response as a QLab Reply
+        Qcmd.context.qlab.send osc_message do |response|
+          Qcmd.debug "[CLI send_command] converting OSC::Message to QLab::Reply"
+          yield QLab::Reply.new(response)
+        end
+      else
+        # rely on default response handler
+        Qcmd.context.qlab.send(osc_message)
+      end
+    end
+
+    def send_workspace_command _command, *args
+      command = "workspace/#{ Qcmd.context.workspace.id }/#{ _command }"
+      send_command(command, *args)
+    end
+
+    ## QLab commands
+
+    def load_cues
+      cues = Qcmd::Action.evaluate('/cueLists')
+      Qcmd.context.workspace.cue_lists = cues.map {|cue_list| Qcmd::QLab::CueList.new(cue_list)}
+    end
   end
 end