gretl 1.0.4 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1656965332fced86693ad3f2c07fdd3ddf9a7456ee6985109813e5d92226523f
-  data.tar.gz: d5c7cc8aac92b0d20d7da86f7b0e258e336445fa38cbf78e4560b3a54d5fe4d3
+  metadata.gz: 4c766301a9c384e993a02eebdb5a67d600f457de87ac78baba481f3fcc8fca10
+  data.tar.gz: a025513173739016a89e6eb8b8413719bb6159d0ecae5c2af4a6bb726ec21999
 SHA512:
-  metadata.gz: fa39a4f95613e614c4ea3ba13eed47d9a5ce770fba0416f3ed8b2718bebcdab2b72f7acd24d715eead4a112a8d70609ad78a797169b55f5ca2fa969126609db4
-  data.tar.gz: 664e92a0787ac6c3b81421372475234f904346c71862b862f09653ac173383de5d403382552add34518c9d76cbb023696c99a9b9403c8330c37195e110029097
+  metadata.gz: a07ef48d121f1fa1daa154533974aee8e44042b8bc90a632d4327c22d4c5de5baed59097021794eb20591447340c47f9d3156f3a4ddcef6529d77e82fa7fbd22
+  data.tar.gz: 4aaa684b0aaa0aa8c09f907a07c3a559dd1f96191a35fbb25f2267207dfcf008db9d4497f7dd95c955b6c55c376997c6136b1329bbf14c462ead7705d4e8c3b7

data/lib/gretl.rb

@@ -155,6 +155,218 @@ module Gretl
     end
   end
 
-  # Default client
+  CLOUD_API = "https://api.gretl.dev"
+
+  class K8sClient
+    def initialize(token)
+      @token = token
+    end
+
+    def clusters
+      _cloud_get("/k8s/clusters")
+    end
+
+    def workloads(cluster_id: nil)
+      path = cluster_id ? "/k8s/clusters/#{cluster_id}/workloads" : "/k8s/workloads"
+      _cloud_get(path)
+    end
+
+    def sync(cluster_id)
+      _cloud_post("/k8s/clusters/#{cluster_id}/sync")
+    end
+
+    def sleep(workload_id)
+      _cloud_post("/k8s/workloads/#{workload_id}/sleep")
+    end
+
+    def wake(workload_id)
+      _cloud_post("/k8s/workloads/#{workload_id}/wake")
+    end
+
+    def tether(workload_id, container_port:, label: nil)
+      body = { container_port: container_port }
+      body[:label] = label if label
+      _cloud_post("/k8s/workloads/#{workload_id}/tether", body)
+    end
+
+    def detach(tether_id)
+      _cloud_post("/k8s/tethers/#{tether_id}/deactivate")
+    end
+
+    def tethers
+      _cloud_get("/k8s/tethers")
+    end
+
+    def auto_sleep(workload_id)
+      _cloud_get("/k8s/workloads/#{workload_id}/auto-sleep")
+    end
+
+    def set_auto_sleep(workload_id, enabled:, idle_timeout_minutes:)
+      _cloud_put("/k8s/workloads/#{workload_id}/auto-sleep",
+                 { auto_sleep_enabled: enabled, idle_timeout_minutes: idle_timeout_minutes })
+    end
+
+    private
+
+    def _cloud_get(path)
+      uri = URI("#{CLOUD_API}#{path}")
+      req = Net::HTTP::Get.new(uri, "Authorization" => "Bearer #{@token}")
+      _cloud_call(uri, req)
+    end
+
+    def _cloud_post(path, body = nil)
+      uri = URI("#{CLOUD_API}#{path}")
+      req = Net::HTTP::Post.new(uri, "Authorization" => "Bearer #{@token}", "Content-Type" => "application/json")
+      req.body = body.to_json if body
+      _cloud_call(uri, req)
+    end
+
+    def _cloud_put(path, body)
+      uri = URI("#{CLOUD_API}#{path}")
+      req = Net::HTTP::Put.new(uri, "Authorization" => "Bearer #{@token}", "Content-Type" => "application/json")
+      req.body = body.to_json
+      _cloud_call(uri, req)
+    end
+
+    def _cloud_call(uri, req)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = 10
+      http.read_timeout = 10
+      res = http.request(req)
+      raise "Gretl API error #{res.code}: #{res.body}" unless res.is_a?(Net::HTTPSuccess)
+      JSON.parse(res.body, symbolize_names: true)
+    rescue Errno::ECONNREFUSED => e
+      raise "Cannot reach Gretl API: #{e}"
+    end
+  end
+
+  class Client
+    def initialize(token: nil)
+      _token = token || ENV.fetch("GR_TOKEN", "")
+      @k8s = K8sClient.new(_token)
+    end
+
+    attr_reader :k8s
+
+    def ports = Gretl._fetch_ports
+    def port(query) = Gretl._resolve(query)
+    def active = Gretl._fetch_ports.select(&:active)
+    def inactive = Gretl._fetch_ports.reject(&:active)
+
+    def start(query)
+      matches = Gretl._resolve(query)
+      raise ArgumentError, "No port found matching #{query.inspect}" if matches.empty?
+      matches.each do |p|
+        Gretl._request(:post, "/ports/#{p.port}/start") if !p.active && p.has_command
+      end
+      matches
+    end
+
+    def stop(query)
+      matches = Gretl._resolve(query)
+      raise ArgumentError, "No port found matching #{query.inspect}" if matches.empty?
+      matches.each do |p|
+        Gretl._request(:post, "/ports/#{p.port}/stop") if p.active
+      end
+      matches
+    end
+
+    def start_group(group)
+      matches = Gretl._fetch_ports.select { |p| p.group&.downcase == group.downcase }
+      raise ArgumentError, "No ports found in group #{group.inspect}" if matches.empty?
+      matches.each { |p| Gretl._request(:post, "/ports/#{p.port}/start") if !p.active && p.has_command }
+      matches
+    end
+
+    def stop_group(group)
+      matches = Gretl._fetch_ports.select { |p| p.group&.downcase == group.downcase }
+      raise ArgumentError, "No ports found in group #{group.inspect}" if matches.empty?
+      matches.each { |p| Gretl._request(:post, "/ports/#{p.port}/stop") if p.active }
+      matches
+    end
+
+    def status_group(group)
+      matches = Gretl._fetch_ports.select { |p| p.group&.downcase == group.downcase }
+      raise ArgumentError, "No ports found in group #{group.inspect}" if matches.empty?
+      matches
+    end
+
+    def remove(query)
+      matches = Gretl._resolve(query)
+      raise ArgumentError, "No port found matching #{query.inspect}" if matches.empty?
+      matches.each { |p| Gretl._request(:delete, "/ports/#{p.port}") }
+      matches
+    end
+
+    def wait_for_active(query, timeout: 30, interval: 0.5)
+      deadline = Time.now + timeout
+      while Time.now < deadline
+        Gretl._resolve(query).each { |p| return p if p.active }
+        sleep interval
+      end
+      raise "Port matching #{query.inspect} did not become active within #{timeout}s"
+    end
+
+    def add(port, name: nil, cmd: nil, group: nil, cwd: nil)
+      Gretl._ensure_daemon
+      uri = URI("#{Gretl::BASE}/ports")
+      body = { port: port }
+      body[:name]  = name  if name
+      body[:cmd]   = cmd   if cmd
+      body[:group] = group if group
+      body[:cwd]   = cwd   if cwd
+      http = Net::HTTP.new(uri.host, uri.port)
+      req = Net::HTTP::Post.new(uri, "Content-Type" => "application/json")
+      req.body = body.to_json
+      res = http.request(req)
+      data = JSON.parse(res.body, symbolize_names: true)
+      Gretl::PortInfo.new(**data.slice(*Gretl::PortInfo.members))
+    end
+
+    def wait_for_inactive(query, timeout: 30, interval: 0.5)
+      deadline = Time.now + timeout
+      while Time.now < deadline
+        Gretl._resolve(query).each { |p| return p if p.stopped? }
+        sleep interval
+      end
+      raise "Port matching #{query.inspect} did not become inactive within #{timeout}s"
+    end
+
+    # ── Agent gateway ─────────────────────────────────────────────────────────
+
+    def agent_list
+      Gretl._fetch_ports.select { |p| p.group&.downcase == "agents" }
+    end
+
+    def agent_spinup(name, cmd: nil, port: nil)
+      unless port
+        used = Gretl._fetch_ports.map(&:port).to_set
+        port = 8100
+        port += 1 while used.include?(port) && port <= 8200
+        raise "No available ports in the agent range (8100–8200)" if port > 8200
+      end
+      add(port, name: name, cmd: cmd || "", group: "Agents")
+      Gretl._request(:post, "/ports/#{port}/start")
+      raw = Gretl._request(:get, "/ports/#{port}")
+      Gretl::PortInfo.new(**raw.slice(*Gretl::PortInfo.members))
+    end
+
+    def agent_spindown(name)
+      match = agent_list.find { |p| p.name.downcase == name.downcase }
+      raise ArgumentError, "No agent found with name #{name.inspect}" unless match
+      Gretl._request(:post, "/ports/#{match.port}/stop") if match.active
+      Gretl._request(:delete, "/ports/#{match.port}")
+    end
+
+    def agent_logs(name, lines: 50)
+      match = agent_list.find { |p| p.name.downcase == name.downcase }
+      raise ArgumentError, "No agent found with name #{name.inspect}" unless match
+      raw = Gretl._request(:get, "/ports/#{match.port}/logs?lines=#{lines}")
+      raw[:lines] || []
+    end
+  end
+
+  # Default client — token read from GR_TOKEN env var
   PA = Client.new
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gretl
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.1.0
 platform: ruby
 authors:
 - Gretl
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-05-15 00:00:00.000000000 Z
+date: 2026-06-09 00:00:00.000000000 Z
 dependencies: []
 description:
 email: