glottis 0.3.1 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4f9b168031125cddf48f2087d3e3cd6c849e9a16972866b21db5d38c9cd2f83e
-  data.tar.gz: 64495dc081d2130d83ab6f3992e6f40de2bcdde85e65c0b3580cd46adcbf4af5
+  metadata.gz: cbc357e1258fd3dafb205cf7516918290a83f168a50bea6ea27b251ee5fff89d
+  data.tar.gz: 7390b269ea50726f631f1315cad2620e06192c0769efc24d95da09c735e7ed48
 SHA512:
-  metadata.gz: ef03824e6fc0c56a6d1df2a93965f851b1795a9892c9bc35a404cd795514f0a692bdb4dcfdcd6b06896f61241fb4010186395b1d845c88a896a709bef6c3c5d9
-  data.tar.gz: 77c0d6bd62771b0fd28af07625ef8f1cedb986655ff68eb9bb0260c92beb47ca1b26c42f0b0cc482b6bb503599363e5daa81304546a8680865d073476329d613
+  metadata.gz: 1779ab3291678ed3b9fb52e537f2362f2d70b8ca83132db41685676df001f3d632fb858ed3408274ecf78dda20f64969824dd1dca793a1dc2dedb216489b59e2
+  data.tar.gz: 81de67b3295200ac4108f4b691c78e5f41a308171bfce76facdabe7c31c64ec98bb908e17dff76025483b4afd7bd5b7c365ca192e76d62f66950e5fab9f4f075

data/CHANGELOG.md

@@ -5,6 +5,19 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semmle.com/semver/1.0.0/).
 
+## [0.4.1] - 2026-07-24
+
+### Changed
+- Production release with Ruby 3.4+ compatibility, GitHub Actions CI, and live Valyx server integration.
+- Added GitHub Release badge and explicit `Content-Type: application/json` headers.
+- Enhanced `RemoteInputHandler` with Server-Sent Events (SSE) stream parsing (`data: {...}`).
+- Enhanced `RemoteOutputHandler` with automatic session cookie forwarding (`SID`) and strict JSON payload formatting (`{"to": "*", "body": "..."}`).
+
+## [0.4.0] - 2026-07-24
+
+### Changed
+- Minor version release for full Ruby 3.4+ compatibility and modernized dependency stack.
+
 ## [0.3.1] - 2026-07-24
 
 ### Changed

data/README.md

@@ -3,6 +3,7 @@
 A CLI for the [valyx](https://github.com/maxdeliso/valyx) message passing server.
 
 [![CI](https://github.com/maxdeliso/glottis/actions/workflows/ci.yml/badge.svg)](https://github.com/maxdeliso/glottis/actions/workflows/ci.yml)
+[![GitHub Release](https://img.shields.io/github/v/release/maxdeliso/glottis)](https://github.com/maxdeliso/glottis/releases/latest)
 [![Gem Version](https://badge.fury.io/rb/glottis.svg)](https://badge.fury.io/rb/glottis)
 
 ## Requirements
@@ -17,7 +18,7 @@ Install the gem by executing:
 
 Or add it to your application's Gemfile:
 
-    $ gem 'glottis', '~> 0.3'
+    $ gem 'glottis', '~> 0.4'
 
 ## Usage
 

data/lib/glottis/client.rb

@@ -42,14 +42,21 @@ module Glottis
     private
 
     def start_handlers
+      remote_output = Handlers::RemoteOutputHandler.new(@outgoing, @host, @port)
+      remote_output.start
+
+      sleep 0.1 until remote_output.cookie || remote_output.sid
+
+      cookie = remote_output.cookie
+      remote_input = Handlers::RemoteInputHandler.new(@incoming, @host, @port, cookie)
+      remote_input.start
+
       @handlers = [
-        Handlers::ConsoleInputHandler.new(@outgoing),
-        Handlers::ConsoleOutputHandler.new(@incoming),
-        Handlers::RemoteInputHandler.new(@incoming, @host, @port),
-        Handlers::RemoteOutputHandler.new(@outgoing, @host, @port)
+        Handlers::ConsoleInputHandler.new(@outgoing).start,
+        Handlers::ConsoleOutputHandler.new(@incoming).start,
+        remote_input,
+        remote_output
       ]
-
-      @handlers.each(&:start)
     end
 
     def stop_handlers

data/lib/glottis/handlers/remote_input_handler.rb

@@ -1,86 +1,117 @@
-# frozen_string_literal: true
-
-require 'logger'
-require 'uri'
-require 'net/http'
-require 'json'
-
-module Glottis
-  module Handlers
-    # Manages stream input from the remote valyx server.
-    class RemoteInputHandler
-      PROTOCOL = 'http'
-      STREAM_DELIMITER = "\0"
-      READ_TIMEOUT = 3600
-      REMOTE_PATHS = {
-        get_message_stream: '/api/messages/stream'
-      }.freeze
-
-      def initialize(incoming, host, port)
-        @incoming = incoming
-        @host = host
-        @port = port
-        @running = false
-        @thread = nil
-        @buffer = String.new
-        setup_http
-      end
-
-      def start
-        @running = true
-        @thread = Thread.new do
-          @http.start
-          read_loop
-        end
-        self
-      end
-
-      def join
-        @thread&.join
-      end
-
-      def cleanup
-        @running = false
-        @http.finish if @http.started?
-        @thread&.kill if @thread&.alive?
-      end
-
-      private
-
-      def setup_http
-        @http = Net::HTTP.new(@host, @port)
-        @http.open_timeout = 1
-        @http.read_timeout = READ_TIMEOUT
-      end
-
-      def read_loop
-        Client.logger.info('reading stream...')
-        @http.get(REMOTE_PATHS.fetch(:get_message_stream)) do |chunk|
-          break unless @running
-
-          Client.logger.debug("got chunk of length: #{chunk.length}")
-          process_chunk(chunk)
-        end
-      rescue StandardError => e
-        Client.logger.error("Error reading message stream: #{e.message}") if @running
-      end
-
-      def process_chunk(chunk)
-        @buffer << chunk
-
-        while (delimiter_index = @buffer.index(STREAM_DELIMITER))
-          msg_raw = @buffer.slice!(0..delimiter_index)
-          msg_data = msg_raw.chomp(STREAM_DELIMITER)
-          next if msg_data.empty?
-
-          begin
-            parsed_msg = JSON.parse(msg_data)
-            @incoming.push(parsed_msg)
-          rescue JSON::ParserError => e
-            Client.logger.warn("Failed to parse JSON payload: #{e.message}")
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'logger'
+require 'uri'
+require 'net/http'
+require 'json'
+
+module Glottis
+  module Handlers
+    # Manages stream input from the remote valyx server.
+    class RemoteInputHandler
+      PROTOCOL = 'http'
+      STREAM_DELIMITER = "\0"
+      READ_TIMEOUT = 3600
+      REMOTE_PATHS = {
+        get_message_stream: '/api/v1/messages/stream',
+        legacy_message_stream: '/api/messages/stream'
+      }.freeze
+
+      def initialize(incoming, host, port, cookie = nil)
+        @incoming = incoming
+        @host = host
+        @port = port
+        @cookie = cookie
+        @running = false
+        @thread = nil
+        @buffer = String.new
+        setup_http
+      end
+
+      def start
+        @running = true
+        @thread = Thread.new do
+          @http.start
+          read_loop
+        end
+        self
+      end
+
+      def join
+        @thread&.join
+      end
+
+      def cleanup
+        @running = false
+        @http.finish if @http.started?
+        @thread&.kill if @thread&.alive?
+      end
+
+      private
+
+      def setup_http
+        @http = Net::HTTP.new(@host, @port)
+        @http.open_timeout = 2
+        @http.read_timeout = READ_TIMEOUT
+      end
+
+      def read_loop
+        Client.logger.info('reading stream...')
+        headers = @cookie ? { 'Cookie' => @cookie } : {}
+
+        stream_request(headers) do |chunk|
+          break unless @running
+
+          process_chunk(chunk)
+        end
+      rescue StandardError => e
+        Client.logger.error("Error reading message stream: #{e.message}") if @running
+      end
+
+      def stream_request(headers, &block)
+        req = Net::HTTP::Get.new(REMOTE_PATHS.fetch(:get_message_stream), headers)
+
+        @http.request(req) do |response|
+          if Integer(response.code) == 404
+            legacy_req = Net::HTTP::Get.new(REMOTE_PATHS.fetch(:legacy_message_stream), headers)
+            @http.request(legacy_req) { |legacy_resp| legacy_resp.read_body(&block) }
+          else
+            response.read_body(&block)
+          end
+        end
+      end
+
+      def process_chunk(chunk)
+        @buffer << chunk
+
+        # Process SSE format ("data: {...}\n\n")
+        while (line_end = @buffer.index("\n"))
+          line = @buffer.slice!(0..line_end).strip
+          next if line.empty? || line.start_with?(':')
+
+          if line.start_with?('data:')
+            json_str = line.sub(/^data:\s*/, '').chomp
+            parse_and_push(json_str)
+          end
+        end
+
+        # Process null-delimited format
+        while (delimiter_index = @buffer.index(STREAM_DELIMITER))
+          msg_raw = @buffer.slice!(0..delimiter_index)
+          msg_data = msg_raw.chomp(STREAM_DELIMITER)
+          parse_and_push(msg_data)
+        end
+      end
+
+      def parse_and_push(raw)
+        return if raw.empty?
+
+        parsed_msg = JSON.parse(raw)
+        parsed_msg['msg'] ||= parsed_msg['body']
+        @incoming.push(parsed_msg)
+      rescue JSON::ParserError => e
+        Client.logger.warn("Failed to parse JSON payload: #{e.message}")
+      end
+    end
+  end
+end

data/lib/glottis/handlers/remote_output_handler.rb

@@ -1,96 +1,126 @@
-# frozen_string_literal: true
-
-require 'logger'
-require 'uri'
-require 'net/http'
-require 'json'
-
-module Glottis
-  module Handlers
-    # Manages posting outgoing messages to the remote valyx server.
-    class RemoteOutputHandler
-      POLL_INTERVAL = 0.1
-      PROTOCOL = 'http'
-
-      REMOTE_PATHS = {
-        get_session: '/api/session',
-        post_message: '/api/message'
-      }.freeze
-
-      def initialize(outgoing, host, port)
-        @outgoing = outgoing
-        @host = host
-        @port = port
-        @running = false
-        @thread = nil
-        @sid = nil
-        setup_http
-      end
-
-      def start
-        @running = true
-        @thread = Thread.new do
-          @http.start
-          request_session
-
-          send_queued while @running
-        end
-        self
-      end
-
-      def join
-        @thread&.join
-      end
-
-      def cleanup
-        @running = false
-        @http.finish if @http.started?
-        @thread&.kill if @thread&.alive?
-      end
-
-      private
-
-      def setup_http
-        @http = Net::HTTP.new(@host, @port)
-        @http.open_timeout = 1
-        @http.read_timeout = 1
-      end
-
-      def request_session
-        Client.logger.info('making initial request for session...')
-
-        session_req = @http.get(REMOTE_PATHS.fetch(:get_session))
-        response = JSON.parse(session_req.body)
-
-        raise "failed to retrieve session: #{response}" if Integer(session_req.code) != 201
-
-        @sid = response['sid']
-        Client.logger.info("current session id: #{@sid}")
-      end
-
-      def if_not_ok(http_req, ok_code = 200)
-        yield http_req.body if Integer(http_req.code) != ok_code
-      end
-
-      def send_queued
-        raw_msg = @outgoing.pop
-        return if raw_msg.nil? || raw_msg == :shutdown
-
-        Client.logger.info("processing message with #{@outgoing.size} messages outgoing")
-
-        message_data = {
-          from: @sid,
-          to: '*',
-          msg: raw_msg
-        }.to_json
-
-        headers = { 'Content-Type' => 'application/json' }
-        post_req = @http.post(REMOTE_PATHS.fetch(:post_message), message_data, headers)
-
-        if_not_ok(post_req) do |err|
-          Client.logger.warn("failed to post message: #{message_data} #{err}")
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'logger'
+require 'uri'
+require 'net/http'
+require 'json'
+
+module Glottis
+  module Handlers
+    # Manages posting outgoing messages to the remote valyx server.
+    class RemoteOutputHandler
+      POLL_INTERVAL = 0.1
+      PROTOCOL = 'http'
+
+      REMOTE_PATHS = {
+        get_session: '/api/v1/session',
+        legacy_session: '/api/session',
+        post_message: '/api/v1/messages',
+        legacy_post_message: '/api/message'
+      }.freeze
+
+      attr_reader :cookie, :sid
+
+      def initialize(outgoing, host, port)
+        @outgoing = outgoing
+        @host = host
+        @port = port
+        @running = false
+        @thread = nil
+        @sid = nil
+        @cookie = nil
+        setup_http
+      end
+
+      def start
+        @running = true
+        @thread = Thread.new do
+          @http.start
+          request_session
+
+          send_queued while @running
+        end
+        self
+      end
+
+      def join
+        @thread&.join
+      end
+
+      def cleanup
+        @running = false
+        @http.finish if @http.started?
+        @thread&.kill if @thread&.alive?
+      end
+
+      private
+
+      def setup_http
+        @http = Net::HTTP.new(@host, @port)
+        @http.open_timeout = 2
+        @http.read_timeout = 2
+      end
+
+      def request_session
+        Client.logger.info('making initial request for session...')
+
+        headers = { 'Content-Type' => 'application/json' }
+        session_req = fetch_session(headers)
+
+        code = Integer(session_req.code)
+        raise "failed to retrieve session: #{session_req.body}" unless [200, 201].include?(code)
+
+        parse_session_response(session_req)
+      end
+
+      def fetch_session(headers)
+        req = @http.post(REMOTE_PATHS.fetch(:get_session), '', headers)
+        return req if Integer(req.code) != 404
+
+        @http.get(REMOTE_PATHS.fetch(:legacy_session))
+      end
+
+      def parse_session_response(session_req)
+        if session_req['set-cookie']
+          raw_cookie = session_req['set-cookie']
+          @cookie = raw_cookie.split(';').first
+        end
+
+        response = begin
+          JSON.parse(session_req.body)
+        rescue StandardError
+          {}
+        end
+
+        @sid = response['username'] || response['sid'] || @cookie
+        Client.logger.info("current session id: #{@sid}")
+      end
+
+      def if_not_ok(http_req, ok_codes = [200, 201])
+        yield http_req.body unless ok_codes.include?(Integer(http_req.code))
+      end
+
+      def send_queued
+        raw_msg = @outgoing.pop
+        return if raw_msg.nil? || raw_msg == :shutdown
+
+        Client.logger.info("processing message with #{@outgoing.size} messages outgoing")
+
+        headers = { 'Content-Type' => 'application/json' }
+        headers['Cookie'] = @cookie if @cookie
+
+        modern_data = { to: '*', body: raw_msg }.to_json
+        post_req = @http.post(REMOTE_PATHS.fetch(:post_message), modern_data, headers)
+
+        if Integer(post_req.code) == 404
+          legacy_data = { from: @sid, to: '*', msg: raw_msg }.to_json
+          post_req = @http.post(REMOTE_PATHS.fetch(:legacy_post_message), legacy_data, headers)
+        end
+
+        if_not_ok(post_req) do |err|
+          Client.logger.warn("failed to post message: #{raw_msg} #{err}")
+        end
+      end
+    end
+  end
+end

data/lib/glottis/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Glottis
-  VERSION = '0.3.1'
+  VERSION = '0.4.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: glottis
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.1
 platform: ruby
 authors:
 - Max DeLiso