watchfor 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8a768a7411f989ca33ba64fd4a8ea911931a93b9265421c1e12664b140cf7aed
+  data.tar.gz: 64381c817f5250cb897219319a6c29d851759f7ce241296e270fc013700207b2
+SHA512:
+  metadata.gz: 1604b16cff061ac83c75dbde6ebbe77c9b513c6bf11654f57cb70bc3b8a0007186bded561c02bc6aa4c2a69d2e06e1747864f63d7f9006039549316e3df36644
+  data.tar.gz: 4f9e4d9014ba6491f405564bc1224d8377482db9251d0d37cddfe6e8849f5a406c43c3f3c7f80c9f113bca27e44d0fd5ff29c549e2ab805a4fb34f3b82e2c934

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 WatchFor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,55 @@
+# watchfor (Ruby)
+
+Official Ruby SDK + CLI for [WatchFor](https://watchfor.io) — uptime &
+infrastructure monitoring over the REST API. Zero dependencies (Ruby stdlib only).
+
+Also available: a [TypeScript SDK](https://www.npmjs.com/package/watchfor), a
+[Python SDK](https://pypi.org/project/watchfor/), an
+[MCP server](https://watchfor.io/docs/api/mcp) and an
+[A2A agent](https://watchfor.io/docs/api/a2a).
+
+## Install
+
+```bash
+gem install watchfor
+```
+
+## Quick start
+
+```ruby
+require "watchfor"
+
+wf = Watchfor::Client.new(api_key: "wf_live_...") # Settings → API keys
+
+pp wf.summary
+
+wf.monitors.list["data"].each { |m| puts "#{m['name']} #{m['status']}" }
+
+mon = wf.monitors.create(
+  { name: "example.com", type: "http", target: "https://example.com",
+    interval: 300, locations: ["<location-id>"] }, # from wf.locations
+  idempotency_key: "create-example-1"
+)
+
+wf.incidents.list(status: "firing")["data"].each { |i| puts i["message"] }
+```
+
+Namespaces: `wf.monitors`, `wf.alert_rules`, `wf.incidents`,
+`wf.maintenance_windows`, `wf.contacts`, `wf.contact_groups`. Top-level:
+`wf.summary`, `wf.plan`, `wf.me`, `wf.locations`, `wf.monitor_types`,
+`wf.incident_stats(period)`, `wf.notifications`, `wf.activity`. Errors raise
+`Watchfor::Error` with `#status`, `#code`, `#message`.
+
+## CLI
+
+```bash
+export WATCHFOR_API_KEY=wf_live_...
+watchfor summary
+watchfor monitors
+watchfor incidents
+watchfor checks <monitor_id>
+```
+
+Reference: <https://watchfor.io/openapi.json> · <https://watchfor.io/docs/api>
+
+MIT License.

data/exe/watchfor

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "json"
+require "watchfor"
+
+api_key = ENV["WATCHFOR_API_KEY"]
+base_url = ENV.fetch("WATCHFOR_BASE_URL", Watchfor::DEFAULT_BASE_URL)
+
+args = ARGV.dup
+command = args.shift
+
+if command == "--version"
+  puts "watchfor #{Watchfor::VERSION}"
+  exit 0
+end
+
+if api_key.nil? || api_key.empty?
+  warn "No API key. Set WATCHFOR_API_KEY."
+  exit 2
+end
+
+wf = Watchfor::Client.new(api_key: api_key, base_url: base_url)
+
+begin
+  result =
+    case command
+    when "summary" then wf.summary
+    when "plan" then wf.plan
+    when "monitors" then wf.monitors.list
+    when "locations" then wf.locations
+    when "monitor-types" then wf.monitor_types
+    when "incidents" then wf.incidents.list
+    when "checks" then wf.monitors.checks(args.shift)
+    else
+      warn "Usage: watchfor [summary|plan|monitors|locations|monitor-types|incidents|checks <monitor_id>]"
+      exit 2
+    end
+  puts JSON.pretty_generate(result)
+rescue Watchfor::Error => e
+  warn "error: #{e.message}"
+  exit 1
+end

data/lib/watchfor/client.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module Watchfor
+  DEFAULT_BASE_URL = "https://watchfor.io/api/v1"
+
+  # Raised when the API returns a non-2xx response. Carries the HTTP
+  # +status+ and the API's structured +code+ and +message+.
+  class Error < StandardError
+    attr_reader :status, :code
+
+    def initialize(status, code, message)
+      @status = status
+      @code = code
+      super("[#{status}] #{code}: #{message}")
+    end
+  end
+
+  # Client for the WatchFor REST API (/api/v1). Zero dependencies.
+  #
+  #   wf = Watchfor::Client.new(api_key: "wf_live_...")
+  #   wf.summary
+  #   wf.monitors.list["data"].each { |m| puts "#{m['name']} #{m['status']}" }
+  class Client
+    attr_reader :monitors, :alert_rules, :incidents,
+                :maintenance_windows, :contacts, :contact_groups
+
+    def initialize(api_key:, base_url: DEFAULT_BASE_URL, timeout: 30)
+      raise ArgumentError, "api_key is required" if api_key.nil? || api_key.empty?
+
+      @api_key = api_key
+      @base_url = base_url.chomp("/")
+      @timeout = timeout
+      @monitors = Monitors.new(self)
+      @alert_rules = AlertRules.new(self)
+      @incidents = Incidents.new(self)
+      @maintenance_windows = MaintenanceWindows.new(self)
+      @contacts = Contacts.new(self)
+      @contact_groups = ContactGroups.new(self)
+    end
+
+    # Core request. +query+ and +body+ are optional hashes.
+    def request(method, path, query: nil, body: nil, idempotency_key: nil)
+      uri = URI("#{@base_url}#{path}")
+      unless query.nil? || query.empty?
+        cleaned = query.reject { |_, v| v.nil? || v == "" }
+        uri.query = URI.encode_www_form(cleaned) unless cleaned.empty?
+      end
+
+      klass = {
+        "GET" => Net::HTTP::Get, "POST" => Net::HTTP::Post,
+        "PATCH" => Net::HTTP::Patch, "PUT" => Net::HTTP::Put,
+        "DELETE" => Net::HTTP::Delete
+      }.fetch(method)
+      req = klass.new(uri)
+      req["Authorization"] = "Bearer #{@api_key}"
+      req["Accept"] = "application/json"
+      req["User-Agent"] = "watchfor-ruby/#{Watchfor::VERSION}"
+      req["Idempotency-Key"] = idempotency_key if idempotency_key
+      unless body.nil?
+        req["Content-Type"] = "application/json"
+        req.body = JSON.generate(body)
+      end
+
+      res = Net::HTTP.start(uri.hostname, uri.port,
+                            use_ssl: uri.scheme == "https",
+                            open_timeout: @timeout, read_timeout: @timeout) do |http|
+        http.request(req)
+      end
+
+      raw = res.body.to_s
+      parsed = raw.empty? ? nil : (JSON.parse(raw) rescue nil)
+      unless res.code.to_i.between?(200, 299)
+        err = parsed.is_a?(Hash) ? (parsed["error"] || {}) : {}
+        raise Error.new(res.code.to_i, err["code"] || "http_error",
+                        err["message"] || "HTTP #{res.code}")
+      end
+      parsed.nil? ? { "ok" => true, "status" => res.code.to_i } : parsed
+    end
+
+    # Top-level reads
+    def me = request("GET", "/me")
+    def summary = request("GET", "/summary")
+    def plan = request("GET", "/plan")
+    def incident_stats(period = nil) = request("GET", "/incidents/stats", query: { period: period })
+    def locations = request("GET", "/locations")
+    def monitor_types = request("GET", "/meta/monitor-types")
+    def notifications(**query) = request("GET", "/notifications", query: query)
+    def activity(**query) = request("GET", "/activity", query: query)
+
+    # Namespaces
+    class Namespace
+      def initialize(client) = (@c = client)
+    end
+
+    class Monitors < Namespace
+      def list(**query) = @c.request("GET", "/monitors", query: query)
+      def get(id) = @c.request("GET", "/monitors/#{id}")
+      def create(body, idempotency_key: nil) = @c.request("POST", "/monitors", body: body, idempotency_key: idempotency_key)
+      def update(id, body) = @c.request("PATCH", "/monitors/#{id}", body: body)
+      def delete(id) = @c.request("DELETE", "/monitors/#{id}")
+      def pause(id) = @c.request("POST", "/monitors/#{id}/pause")
+      def resume(id) = @c.request("POST", "/monitors/#{id}/resume")
+      def check_now(id) = @c.request("POST", "/monitors/#{id}/check-now")
+      def uptime(id, period = nil) = @c.request("GET", "/monitors/#{id}/uptime", query: { period: period })
+      def checks(id, **query) = @c.request("GET", "/monitors/#{id}/checks", query: query)
+    end
+
+    class AlertRules < Namespace
+      def list(monitor_id) = @c.request("GET", "/monitors/#{monitor_id}/alert-rules")
+      def get(monitor_id, rule_id) = @c.request("GET", "/monitors/#{monitor_id}/alert-rules/#{rule_id}")
+      def create(monitor_id, body) = @c.request("POST", "/monitors/#{monitor_id}/alert-rules", body: body)
+      def update(monitor_id, rule_id, body) = @c.request("PATCH", "/monitors/#{monitor_id}/alert-rules/#{rule_id}", body: body)
+      def delete(monitor_id, rule_id) = @c.request("DELETE", "/monitors/#{monitor_id}/alert-rules/#{rule_id}")
+    end
+
+    class Incidents < Namespace
+      def list(**query) = @c.request("GET", "/incidents", query: query)
+      def get(id) = @c.request("GET", "/incidents/#{id}")
+      def acknowledge(id) = @c.request("POST", "/incidents/#{id}/acknowledge")
+      def resolve(id) = @c.request("POST", "/incidents/#{id}/resolve")
+    end
+
+    class MaintenanceWindows < Namespace
+      def list(**query) = @c.request("GET", "/maintenance-windows", query: query)
+      def get(id) = @c.request("GET", "/maintenance-windows/#{id}")
+      def create(body, idempotency_key: nil) = @c.request("POST", "/maintenance-windows", body: body, idempotency_key: idempotency_key)
+      def update(id, body) = @c.request("PATCH", "/maintenance-windows/#{id}", body: body)
+      def delete(id) = @c.request("DELETE", "/maintenance-windows/#{id}")
+    end
+
+    class Contacts < Namespace
+      def list(**query) = @c.request("GET", "/contacts", query: query)
+      def get(id) = @c.request("GET", "/contacts/#{id}")
+      def create(body, idempotency_key: nil) = @c.request("POST", "/contacts", body: body, idempotency_key: idempotency_key)
+      def update(id, body) = @c.request("PATCH", "/contacts/#{id}", body: body)
+      def delete(id) = @c.request("DELETE", "/contacts/#{id}")
+    end
+
+    class ContactGroups < Namespace
+      def list(**query) = @c.request("GET", "/contact-groups", query: query)
+      def get(id) = @c.request("GET", "/contact-groups/#{id}")
+      def create(body, idempotency_key: nil) = @c.request("POST", "/contact-groups", body: body, idempotency_key: idempotency_key)
+      def update(id, body) = @c.request("PATCH", "/contact-groups/#{id}", body: body)
+      def delete(id) = @c.request("DELETE", "/contact-groups/#{id}")
+    end
+  end
+end

data/lib/watchfor/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Watchfor
+  VERSION = "0.1.0"
+end

data/lib/watchfor.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "watchfor/version"
+require_relative "watchfor/client"
+
+# Official Ruby SDK for WatchFor — uptime & infrastructure monitoring.
+# See https://watchfor.io/docs/api
+module Watchfor
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: watchfor
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- WatchFor
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-08-28 00:00:00.000000000 Z
+dependencies: []
+description: Zero-dependency Ruby client for the WatchFor REST API (monitors, alert
+  rules, incidents, maintenance windows) plus a `watchfor` CLI.
+email:
+- hello@watchfor.io
+executables:
+- watchfor
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- exe/watchfor
+- lib/watchfor.rb
+- lib/watchfor/client.rb
+- lib/watchfor/version.rb
+homepage: https://watchfor.io/docs/api
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://watchfor.io/docs/api
+  documentation_uri: https://watchfor.io/docs/api
+  changelog_uri: https://watchfor.io/changelog
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.20
+signing_key:
+specification_version: 4
+summary: Official Ruby SDK + CLI for WatchFor — uptime & infrastructure monitoring.
+test_files: []