pbx 0.1.0

data/lib/pbx/app.rb

@@ -0,0 +1,376 @@
+# frozen_string_literal: true
+
+require "bubbletea"
+require "bubbles"
+require "lipgloss"
+require_relative "messages"
+require_relative "views/header"
+require_relative "views/extension_table"
+require_relative "views/active_calls"
+require_relative "views/queue_table"
+require_relative "views/footer"
+require_relative "views/disconnected_screen"
+require_relative "views/info_modal"
+
+module Pbx
+  class App
+    include Bubbletea::Model
+
+    TICK_INTERVAL = 1  # seconds between "time since last change" refresh
+
+    attr_reader :extensions, :active_calls, :queues, :status, :error, :width, :height, :config,
+      :show_info, :system_boot_at, :last_reload_at, :view_mode
+
+    def spinner_view = @spinner.view
+
+    def initialize(bridge:, config:)
+      @bridge = bridge
+      @config = config
+      @extensions = {}
+      @active_calls = {}
+      @queues = {}
+      @status = @config.complete? ? :connecting : :disconnected
+      @error = nil
+      @width = 80
+      @height = 24
+      @table = nil
+      @calls_table = nil
+      @queues_table = nil
+      @show_info = false
+      @view_mode = :peers
+      @spinner = Bubbles::Spinner.new(spinner: Bubbles::Spinners::DOT)
+      @system_boot_at = nil
+      @last_reload_at = nil
+    end
+
+    def init
+      if @config.complete?
+        @spinner, spinner_cmd = @spinner.init
+        [self, Bubbletea.batch(connect_cmd, tick_cmd, spinner_cmd)]
+      else
+        [self, tick_cmd]
+      end
+    end
+
+    def update(message)
+      case message
+      when Bubbletea::KeyMessage
+        if @show_info
+          @show_info = false
+          return [self, nil]
+        end
+
+        return [self, Bubbletea.quit] if quit_key?(message)
+
+        if message.runes? && message.char == "i"
+          @show_info = true
+          return [self, nil]
+        end
+
+        if message.runes? && message.char == "p" && @status == :connected
+          @view_mode = :peers
+          rebuild_table
+          return [self, nil]
+        end
+
+        if message.runes? && message.char == "c" && @status == :connected
+          @view_mode = :calls
+          rebuild_table
+          return [self, nil]
+        end
+
+        if message.runes? && message.char == "q" && @status == :connected
+          @view_mode = :queues
+          return [self, nil]
+        end
+
+        active_table = case @view_mode
+        when :calls then @calls_table
+        when :queues then @queues_table
+        else @table
+        end
+        if active_table && @status == :connected
+          updated, table_cmd = active_table.update(message)
+          case @view_mode
+          when :calls then @calls_table = updated
+          when :queues then @queues_table = updated
+          else @table = updated
+          end
+          return [self, table_cmd]
+        end
+
+      when Bubbletea::WindowSizeMessage
+        @width = message.width
+        @height = message.height
+        if @status == :connected
+          rebuild_table
+          rebuild_calls_table
+          rebuild_queues_table
+        end
+
+      when Messages::ConnectionEstablished
+        @status = :connected
+        @error = nil
+        message.peers.each { |p| @extensions[p.id] = p }
+        @queues = message.queues
+        rebuild_table
+        rebuild_queues_table
+        return [self, wait_for_event_cmd]
+
+      when Messages::ConnectionLost
+        @status = :lost
+        @error = message.reason
+        return [self, wait_for_event_cmd]
+
+      when Messages::PeerDiscovered
+        @extensions[message.peer.id] = message.peer
+        rebuild_table
+        return [self, wait_for_event_cmd]
+
+      when Messages::PeerStatusChanged
+        if (peer = @extensions[message.peer_name])
+          @extensions[peer.id] = Peer.new(
+            id: peer.id,
+            name: peer.name,
+            ip_address: message.ip_address || peer.ip_address,
+            ip_port: message.ip_port || peer.ip_port,
+            status: message.status,
+            type: peer.type,
+            dynamic: peer.dynamic,
+            user_agent: peer.user_agent,
+            rtt_ms: message.rtt_ms || peer.rtt_ms,
+            last_change_at: message.at
+          )
+          rebuild_table
+        end
+        return [self, wait_for_event_cmd]
+
+      when Messages::CallStarted
+        @active_calls[message.uniqueid] = Call.new(
+          uniqueid: message.uniqueid,
+          channel: message.channel,
+          caller_id: message.caller_id,
+          caller_name: message.caller_name,
+          connected_to: nil,
+          state: message.state,
+          started_at: message.started_at,
+          outcome: nil,
+          held: false,
+          dialplan_app: nil,
+          dialplan_exten: nil
+        )
+        rebuild_table
+        rebuild_calls_table
+        return [self, wait_for_event_cmd]
+
+      when Messages::CallEnded
+        @active_calls.delete(message.uniqueid)
+        rebuild_table
+        rebuild_calls_table
+        return [self, wait_for_event_cmd]
+
+      when Messages::CallStateChanged
+        if (call = @active_calls[message.uniqueid])
+          @active_calls[call.uniqueid] = call.with(
+            connected_to: message.connected_to || call.connected_to,
+            state: message.state
+          )
+          rebuild_table
+          rebuild_calls_table
+        end
+        return [self, wait_for_event_cmd]
+
+      when Messages::DialCompleted
+        if (call = @active_calls[message.uniqueid])
+          @active_calls[call.uniqueid] = call.with(outcome: message.dial_status)
+          rebuild_table
+          rebuild_calls_table
+        end
+        return [self, wait_for_event_cmd]
+
+      when Messages::CallHeld
+        if (call = @active_calls[message.uniqueid])
+          @active_calls[call.uniqueid] = call.with(held: true)
+          rebuild_table
+          rebuild_calls_table
+        end
+        return [self, wait_for_event_cmd]
+
+      when Messages::CallUnheld
+        if (call = @active_calls[message.uniqueid])
+          @active_calls[call.uniqueid] = call.with(held: false)
+          rebuild_table
+          rebuild_calls_table
+        end
+        return [self, wait_for_event_cmd]
+
+      when Messages::CallDialplanUpdate
+        if (call = @active_calls[message.uniqueid])
+          @active_calls[call.uniqueid] = call.with(
+            dialplan_app: message.application,
+            dialplan_exten: message.exten
+          )
+          rebuild_table
+          rebuild_calls_table
+        end
+        return [self, wait_for_event_cmd]
+
+      when Messages::QueueCallCompleted
+        if (q = @queues[message.queue])
+          @queues[message.queue] = q.with(
+            completed: q.completed + 1,
+            last_holdtime: message.holdtime
+          )
+          rebuild_queues_table
+        end
+        return [self, wait_for_event_cmd]
+
+      when Messages::QueueCallerCountChanged
+        if (q = @queues[message.queue])
+          @queues[message.queue] = q.with(calls_waiting: message.count)
+          rebuild_queues_table
+        end
+        return [self, wait_for_event_cmd]
+
+      when Messages::QueueCallerAbandoned
+        if (q = @queues[message.queue])
+          @queues[message.queue] = q.with(abandoned: q.abandoned + 1)
+          rebuild_queues_table
+        end
+        return [self, wait_for_event_cmd]
+
+      when Messages::QueueMemberUpdated
+        q = @queues[message.queue] || CallQueue.new(
+          name: message.queue, strategy: "unknown", calls_waiting: 0,
+          completed: 0, abandoned: 0, holdtime: 0, members: {}
+        )
+        existing = q.members[message.interface]
+        updated_member = if existing
+          existing.with(
+            name: message.name.empty? ? existing.name : message.name,
+            status: message.status || existing.status,
+            paused: message.paused
+          )
+        else
+          QueueMember.new(
+            queue: message.queue,
+            name: message.name,
+            interface: message.interface,
+            status: message.status || "unknown",
+            paused: message.paused
+          )
+        end
+        @queues[message.queue] = q.with(members: q.members.merge(message.interface => updated_member))
+        rebuild_queues_table
+        return [self, wait_for_event_cmd]
+
+      when Messages::QueueMemberGone
+        if (q = @queues[message.queue])
+          @queues[message.queue] = q.with(members: q.members.reject { |k, _| k == message.interface })
+          rebuild_queues_table
+        end
+        return [self, wait_for_event_cmd]
+
+      when Messages::SystemInfo
+        @system_boot_at = message.received_at - message.uptime_secs
+        @last_reload_at = message.received_at - message.last_reload_secs
+        return [self, wait_for_event_cmd]
+
+      when Messages::AmiError
+        @error = message.error.to_s
+        return [self, wait_for_event_cmd]
+
+      when Messages::Tick
+        rebuild_table if @status == :connected && !@extensions.empty?
+        return [self, tick_cmd]
+
+      end
+
+      @spinner, spinner_cmd = @spinner.update(message)
+      [self, spinner_cmd]
+    end
+
+    def view
+      return Views::InfoModal.call(self) if @show_info
+
+      header = Views::Header.call(self)
+      body = build_body
+      footer = Views::Footer.call(self)
+      content = Lipgloss.join_vertical(:left, header, body, footer)
+      Lipgloss.place(@width, @height, :left, :top, content)
+    end
+
+    private
+
+    def build_body
+      case @status
+      when :disconnected
+        Views::DisconnectedScreen.call(self)
+      when :connecting
+        ""
+      else
+        if @view_mode == :calls
+          Views::ActiveCalls.render(@active_calls, @width, list_height(@active_calls.size), table: @calls_table)
+        elsif @view_mode == :queues
+          Views::QueueTable.render(@queues, @width, list_height(@queues.size), table: @queues_table)
+        else
+          @extensions.empty? ? Views::ExtensionTable.render_empty : (@table&.view || Views::ExtensionTable.render_empty)
+        end
+      end
+    end
+
+    def rebuild_table
+      table_height = [@height - 6, 5].max
+      @table = Views::ExtensionTable.build(@extensions, table_height)
+    end
+
+    def rebuild_calls_table
+      @calls_table = Views::ActiveCalls.build(@active_calls, list_height(@active_calls.size))
+    end
+
+    def rebuild_queues_table
+      @queues_table = Views::QueueTable.build(@queues, list_height(@queues.size))
+    end
+
+    # Rows available to a list body, never fewer than one. The upper bound is
+    # floored before clamping because a bare clamp(1, @height - 8) raises
+    # ArgumentError once the terminal is shorter than nine rows.
+    def list_height(count)
+      count.clamp(1, [@height - 8, 1].max)
+    end
+
+    def connect_cmd
+      -> {
+        begin
+          @bridge.connect_and_login
+          peers = @bridge.discover_peers
+          queues = @bridge.discover_queues
+          @bridge.subscribe
+          Messages::ConnectionEstablished.new(
+            remote: "#{@config.host}:#{@config.port}",
+            peers: peers,
+            queues: queues
+          )
+        rescue => e
+          Messages::ConnectionLost.new(reason: e.message)
+        end
+      }
+    end
+
+    def wait_for_event_cmd
+      -> { @bridge.next_event }
+    end
+
+    def tick_cmd
+      Bubbletea.tick(TICK_INTERVAL) { Messages::Tick.new(at: Time.now) }
+    end
+
+    def quit_key?(msg)
+      return true if msg.esc?
+      return true if msg.ctrl? && msg.key_type == Bubbletea::KeyMessage::KEY_CTRL_C
+      return true if msg.runes? && msg.char == "e"
+
+      false
+    end
+  end
+end

data/lib/pbx/call.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pbx
+  Call = Data.define(
+    :uniqueid, :channel, :caller_id, :caller_name,
+    :connected_to, :state, :started_at,
+    :outcome, :held, :dialplan_app, :dialplan_exten
+  )
+end

data/lib/pbx/call_queue.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pbx
+  CallQueue = Data.define(:name, :strategy, :calls_waiting, :completed, :abandoned, :holdtime, :last_holdtime, :members) do
+    def initialize(name:, strategy:, calls_waiting:, completed:, abandoned:, holdtime:, members:, last_holdtime: nil)
+      super
+    end
+  end
+end

data/lib/pbx/cli.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "thor"
+require "bubbletea"
+require_relative "version"
+require_relative "config"
+require_relative "ami_bridge"
+require_relative "app"
+
+module Pbx
+  class CLI < Thor
+    desc "monitor", "Open the TUI and monitor Asterisk extension status"
+    long_desc <<~DESC
+      Connects to an Asterisk PBX via AMI, auto-discovers SIP/PJSIP extensions,
+      and displays real-time line status in a terminal UI.
+
+      Connection parameters can be supplied via CLI flags or a YAML config file
+      (use --config). CLI flags always override YAML values.
+    DESC
+    option :host, type: :string, desc: "AMI hostname or IP (default: 127.0.0.1)"
+    option :port, type: :numeric, desc: "AMI port (default: 5038)"
+    option :user, type: :string, desc: "AMI username"
+    option :secret, type: :string, desc: "AMI secret/password"
+    option :config, type: :string, aliases: "-c", desc: "Path to YAML config file"
+    option :debug, type: :boolean, default: false, desc: "Write AMI debug log to /tmp/pbx_debug.log"
+    def monitor
+      cli_opts = options.to_h.transform_keys(&:to_sym)
+      debug = cli_opts.delete(:debug) { false }
+      cfg = Config.load(cli: cli_opts)
+      bridge = AmiBridge.new(cfg, debug: debug)
+      Bubbletea.run(App.new(bridge: bridge, config: cfg), alt_screen: true)
+    rescue Config::Error => e
+      warn "Error: #{e.message}"
+      exit 1
+    ensure
+      bridge&.shutdown
+    end
+
+    desc "version", "Print pbx version"
+    def version
+      puts "pbx #{Pbx::VERSION}"
+    end
+
+    def self.exit_on_failure? = true
+  end
+end

data/lib/pbx/config.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Pbx
+  module Config
+    class Error < StandardError; end
+
+    Value = Data.define(:host, :port, :user, :secret, :context, :reconnect_backoff) do
+      def complete?
+        user.to_s.strip.length.positive? && secret.to_s.strip.length.positive?
+      end
+    end
+
+    DEFAULTS = {
+      host: "127.0.0.1",
+      port: 5038,
+      user: nil,
+      secret: nil,
+      context: "default",
+      reconnect_backoff: [1, 2, 5, 10]
+    }.freeze
+
+    def self.load(cli: {})
+      from_yaml = cli[:config] ? load_yaml(cli[:config]) : {}
+      merged = DEFAULTS.merge(from_yaml).merge(compact(cli).except(:config))
+      Value.new(**merged)
+    end
+
+    def self.load_yaml(path)
+      raw = YAML.safe_load_file(path, symbolize_names: true)
+      raw.slice(:host, :port, :user, :secret, :context, :reconnect_backoff)
+    rescue Errno::ENOENT
+      raise Error, "Config file not found: #{path}"
+    rescue Psych::Exception => e
+      raise Error, "Invalid YAML config: #{e.message}"
+    end
+
+    def self.compact(hash)
+      hash.reject { |_, v| v.nil? }
+    end
+
+    private_class_method :load_yaml, :compact
+  end
+end

data/lib/pbx/messages.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require "bubbletea"
+
+module Pbx
+  module Messages
+    class PeerDiscovered < Bubbletea::Message
+      attr_reader :peer
+
+      def initialize(peer:)
+        super()
+        @peer = peer
+      end
+    end
+
+    class PeerStatusChanged < Bubbletea::Message
+      attr_reader :peer_name, :status, :ip_address, :ip_port, :rtt_ms, :at
+
+      def initialize(peer_name:, status:, at:, ip_address: nil, ip_port: nil, rtt_ms: nil)
+        super()
+        @peer_name = peer_name
+        @status = status
+        @ip_address = ip_address
+        @ip_port = ip_port
+        @rtt_ms = rtt_ms
+        @at = at
+      end
+    end
+
+    class ConnectionEstablished < Bubbletea::Message
+      attr_reader :remote, :peers, :queues
+
+      def initialize(remote:, peers:, queues: {})
+        super()
+        @remote = remote
+        @peers = peers
+        @queues = queues
+      end
+    end
+
+    class ConnectionLost < Bubbletea::Message
+      attr_reader :reason
+
+      def initialize(reason:)
+        super()
+        @reason = reason
+      end
+    end
+
+    class AmiError < Bubbletea::Message
+      attr_reader :error
+
+      def initialize(error:)
+        super()
+        @error = error
+      end
+    end
+
+    class Tick < Bubbletea::Message
+      attr_reader :at
+
+      def initialize(at:)
+        super()
+        @at = at
+      end
+    end
+
+    class CallStarted < Bubbletea::Message
+      attr_reader :uniqueid, :channel, :caller_id, :caller_name, :state, :started_at
+
+      def initialize(uniqueid:, channel:, caller_id:, caller_name:, state:, started_at:)
+        super()
+        @uniqueid = uniqueid
+        @channel = channel
+        @caller_id = caller_id
+        @caller_name = caller_name
+        @state = state
+        @started_at = started_at
+      end
+    end
+
+    class CallEnded < Bubbletea::Message
+      attr_reader :uniqueid
+
+      def initialize(uniqueid:)
+        super()
+        @uniqueid = uniqueid
+      end
+    end
+
+    class CallStateChanged < Bubbletea::Message
+      attr_reader :uniqueid, :state, :connected_to
+
+      def initialize(uniqueid:, state:, connected_to: nil)
+        super()
+        @uniqueid = uniqueid
+        @state = state
+        @connected_to = connected_to
+      end
+    end
+
+    class DialCompleted < Bubbletea::Message
+      attr_reader :uniqueid, :dial_status
+
+      def initialize(uniqueid:, dial_status:)
+        super()
+        @uniqueid = uniqueid
+        @dial_status = dial_status
+      end
+    end
+
+    class CallHeld < Bubbletea::Message
+      attr_reader :uniqueid
+
+      def initialize(uniqueid:)
+        super()
+        @uniqueid = uniqueid
+      end
+    end
+
+    class CallUnheld < Bubbletea::Message
+      attr_reader :uniqueid
+
+      def initialize(uniqueid:)
+        super()
+        @uniqueid = uniqueid
+      end
+    end
+
+    class CallDialplanUpdate < Bubbletea::Message
+      attr_reader :uniqueid, :context, :exten, :application
+
+      def initialize(uniqueid:, context:, exten:, application:)
+        super()
+        @uniqueid = uniqueid
+        @context = context
+        @exten = exten
+        @application = application
+      end
+    end
+
+    class QueueCallCompleted < Bubbletea::Message
+      attr_reader :queue, :holdtime
+
+      def initialize(queue:, holdtime:)
+        super()
+        @queue = queue
+        @holdtime = holdtime
+      end
+    end
+
+    class QueueCallerCountChanged < Bubbletea::Message
+      attr_reader :queue, :count
+
+      def initialize(queue:, count:)
+        super()
+        @queue = queue
+        @count = count
+      end
+    end
+
+    class QueueCallerAbandoned < Bubbletea::Message
+      attr_reader :queue
+
+      def initialize(queue:)
+        super()
+        @queue = queue
+      end
+    end
+
+    class QueueMemberUpdated < Bubbletea::Message
+      attr_reader :queue, :interface, :name, :status, :paused
+
+      def initialize(queue:, interface:, name:, status:, paused:)
+        super()
+        @queue = queue
+        @interface = interface
+        @name = name
+        @status = status
+        @paused = paused
+      end
+    end
+
+    class QueueMemberGone < Bubbletea::Message
+      attr_reader :queue, :interface
+
+      def initialize(queue:, interface:)
+        super()
+        @queue = queue
+        @interface = interface
+      end
+    end
+
+    class SystemInfo < Bubbletea::Message
+      attr_reader :uptime_secs, :last_reload_secs, :received_at
+
+      def initialize(uptime_secs:, last_reload_secs:, received_at:)
+        super()
+        @uptime_secs = uptime_secs
+        @last_reload_secs = last_reload_secs
+        @received_at = received_at
+      end
+    end
+  end
+end

data/lib/pbx/peer.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Pbx
+  Peer = Data.define(:id, :name, :ip_address, :ip_port, :status, :type, :dynamic, :user_agent, :rtt_ms, :last_change_at)
+end

data/lib/pbx/queue_member.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Pbx
+  QueueMember = Data.define(:queue, :name, :interface, :status, :paused) do
+    def available? = status == "not_in_use" && !paused
+  end
+end