sillydev 1.0.0

data/lib/sillydev/resources.rb

@@ -0,0 +1,844 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module SillyDev
+  # The panel API's endpoints, grouped as in the API docs.
+  #
+  # Each method names the operationId it calls in https://sillydev.co.uk/docs/panel/openapi.json.
+  # Every method returns plain hashes and arrays (string keys), with the {"object", "attributes"}
+  # envelopes removed. Methods named list (and activity) on paginated endpoints return an
+  # Enumerator that fetches the following pages as it goes; their *_page twins return a single
+  # SillyDev::Page, which also carries the list's meta.
+  module Resources
+    # Shared plumbing for the resource classes.
+    class Base
+      def initialize(client)
+        @client = client
+      end
+
+      def inspect
+        "#<#{self.class.name}>"
+      end
+
+      private
+
+      def req(method, path, **kwargs)
+        @client.request(method, path, **kwargs)
+      end
+
+      def seg(value)
+        Client.segment(value)
+      end
+
+      def server_path(server)
+        "/servers/#{seg(server)}"
+      end
+
+      def project_path(project)
+        "/monitoring/projects/#{seg(project)}"
+      end
+
+      # A request body without the optional fields that were left as nil.
+      def body(**fields)
+        fields.compact.transform_keys(&:to_s)
+      end
+
+      # Turns [["a", "b"]] or [{"from" => "a", "to" => "b"}] into [{"from" => "a", "to" => "b"}].
+      def pairs(values, first, second)
+        values.map do |value|
+          if value.is_a?(Hash)
+            { first => value[first] || value[first.to_sym], second => value[second] || value[second.to_sym] }
+          else
+            a, b = value
+            { first => a, second => b }
+          end
+        end
+      end
+
+      # The body with its meta folded in: {key => body, ...meta}.
+      def with_meta(key, raw)
+        return { key => Envelope.unwrap(raw) } unless raw.is_a?(Hash)
+
+        out = { key => Envelope.unwrap(raw.except("meta")) }
+        out.merge!(Envelope.unwrap(raw["meta"])) if raw["meta"].is_a?(Hash)
+        out
+      end
+    end
+
+    # Servers, plus power and console (tags Servers and Power and console).
+    class Servers < Base
+      # Every server the key can reach, fetching page after page. operationId: listServers
+      def list(type: nil, search: nil, uuid: nil, name: nil, description: nil, external_id: nil, include: nil, per_page: nil)
+        @client.paginate("/", server_filters(type, search, uuid, name, description, external_id, include, per_page))
+      end
+
+      # One page of servers. page.meta["pending_orders"] lists paid servers not built yet. operationId: listServers
+      def list_page(page: 1, per_page: nil, type: nil, search: nil, uuid: nil, name: nil, description: nil,
+                    external_id: nil, include: nil)
+        params = server_filters(type, search, uuid, name, description, external_id, include, per_page)
+        @client.page("/", params.merge(page: page))
+      end
+
+      # One server's details. operationId: getServer
+      def get(server, include: nil)
+        req("GET", server_path(server), params: { include: include })
+      end
+
+      # Delete a server you own. name must be the server's current name, as a confirmation. operationId: deleteServer
+      def delete(server, name:)
+        req("DELETE", server_path(server), json: { "name" => name })
+      end
+
+      # Live state and resource use of one server. operationId: getServerResources
+      def resources(server)
+        req("GET", "#{server_path(server)}/resources")
+      end
+
+      # Waits until the server is in state, checking its live state every interval seconds.
+      #
+      # Returns the server's resources from the check that found it in that state. Raises
+      # SillyDev::WaitTimeoutError if it isn't after timeout seconds. For example
+      # servers.start(id) then servers.wait_for_state(id). operationId: getServerResources
+      def wait_for_state(server, state = "running", timeout: 120.0, interval: 2.0)
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+        loop do
+          current = resources(server)
+          return current if current.is_a?(Hash) && current["current_state"] == state
+
+          now_state = current.is_a?(Hash) ? current["current_state"] : nil
+          remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          if remaining <= 0
+            raise WaitTimeoutError.new("server #{server} is #{now_state}, not #{state}, after #{timeout} seconds",
+                                       state: now_state)
+          end
+
+          @client.sleeper.call([interval, remaining].min)
+        end
+      end
+
+      # Live resource use of up to 100 servers, keyed by UUID (full UUIDs only). operationId: listServerResources
+      def resources_many(servers)
+        req("GET", "/resources", params: { servers: Array(servers).join(",") })
+      end
+
+      # The server's activity log, fetching page after page. operationId: listServerActivity
+      def activity(server, event: nil, sort: nil, include: nil, per_page: nil)
+        @client.paginate("#{server_path(server)}/activity",
+                         { "filter[event]" => event, sort: sort, include: include, per_page: per_page })
+      end
+
+      # One page of the server's activity log. operationId: listServerActivity
+      def activity_page(server, page: 1, per_page: nil, event: nil, sort: nil, include: nil)
+        @client.page("#{server_path(server)}/activity",
+                     { page: page, per_page: per_page, "filter[event]" => event, sort: sort, include: include })
+      end
+
+      # Every server permission there is, grouped, with descriptions. operationId: listPermissions
+      def permissions
+        req("GET", "/permissions")
+      end
+
+      # Send "start", "stop", "restart" or "kill". operationId: sendPowerSignal
+      def power(server, signal)
+        req("POST", "#{server_path(server)}/power", json: { "signal" => signal.to_s })
+      end
+
+      # Shortcut for power(server, "start"). operationId: sendPowerSignal
+      def start(server) = power(server, "start")
+
+      # Shortcut for power(server, "stop"). operationId: sendPowerSignal
+      def stop(server) = power(server, "stop")
+
+      # Shortcut for power(server, "restart"). operationId: sendPowerSignal
+      def restart(server) = power(server, "restart")
+
+      # Shortcut for power(server, "kill"). operationId: sendPowerSignal
+      def kill(server) = power(server, "kill")
+
+      # Send a command to the server's console. operationId: sendCommand
+      def command(server, command)
+        req("POST", "#{server_path(server)}/command", json: { "command" => command })
+      end
+
+      # Upload console output to a share link, with secrets hidden; returns the URL. operationId: shareLogs
+      def share_logs(server, content)
+        req("POST", "#{server_path(server)}/logs/share", json: { "content" => content })["url"].to_s
+      end
+
+      # A token and the addresses of the live console: {"token", "socket", "sessions"}. operationId: getWebsocketCredentials
+      def websocket(server)
+        req("GET", "#{server_path(server)}/websocket")["data"]
+      end
+
+      # Open a console session that the panel reads for you; returns the session ID. operationId: openConsoleRelay
+      def open_relay(server)
+        (req("POST", "#{server_path(server)}/websocket/relay")["data"] || {})["session"].to_s
+      end
+
+      # The relay session's messages after the one numbered after: {"events", "missed", "more"}. operationId: pollConsoleRelay
+      def poll_relay(server, session, after: nil)
+        req("GET", "#{server_path(server)}/websocket/relay/#{seg(session)}", params: { after: after })["data"]
+      end
+
+      # Send a websocket message ("send command", "set state"...) through a relay session. operationId: sendConsoleRelay
+      def send_relay(server, session, event, *args)
+        req("POST", "#{server_path(server)}/websocket/relay/#{seg(session)}/send",
+            json: { "event" => event, "args" => args.map(&:to_s) })
+        nil
+      end
+
+      # End a relay session. operationId: closeConsoleRelay
+      def close_relay(server, session)
+        req("DELETE", "#{server_path(server)}/websocket/relay/#{seg(session)}")
+        nil
+      end
+
+      private
+
+      def server_filters(type, search, uuid, name, description, external_id, include, per_page)
+        {
+          type: type,
+          "filter[*]" => search,
+          "filter[uuid]" => uuid,
+          "filter[name]" => name,
+          "filter[description]" => description,
+          "filter[external_id]" => external_id,
+          include: include,
+          per_page: per_page,
+        }
+      end
+    end
+
+    # Rename, reinstall, change the Docker image and the status badge (tag Settings).
+    class Settings < Base
+      # Rename a server and optionally change its description. operationId: renameServer
+      def rename(server, name, description: nil)
+        req("POST", "#{server_path(server)}/settings/rename", json: body(name: name, description: description))
+      end
+
+      # Run the server's install script again. operationId: reinstallServer
+      def reinstall(server)
+        req("POST", "#{server_path(server)}/settings/reinstall")
+      end
+
+      # Switch to another of the egg's Docker images. operationId: setDockerImage
+      def set_docker_image(server, docker_image)
+        req("PUT", "#{server_path(server)}/settings/docker-image", json: { "docker_image" => docker_image })
+      end
+
+      # The public status badge: {"enabled", "show_name", "url", "link", "markdown"}. operationId: getStatusBadge
+      def badge(server)
+        req("GET", "#{server_path(server)}/settings/badge")
+      end
+
+      # Turn the status badge on, or change whether it shows the server's name. operationId: updateStatusBadge
+      def enable_badge(server, show_name: nil)
+        req("PUT", "#{server_path(server)}/settings/badge", json: body(show_name: show_name))
+      end
+
+      # Give the status badge a new address; the old one stops working. operationId: regenerateStatusBadge
+      def regenerate_badge(server)
+        req("POST", "#{server_path(server)}/settings/badge/regenerate")
+      end
+
+      # Turn the status badge off and forget its address. operationId: deleteStatusBadge
+      def disable_badge(server)
+        req("DELETE", "#{server_path(server)}/settings/badge")
+      end
+    end
+
+    # The startup command and variables (tag Startup).
+    class Startup < Base
+      # {"variables" => [...], "startup_command", "raw_startup_command", "docker_images", ...}. operationId: getStartup
+      def get(server)
+        with_meta("variables", req("GET", "#{server_path(server)}/startup", raw: true))
+      end
+
+      # Set one startup variable by its env_variable; returns {"variable" => {...}, "startup_command", ...}.
+      # operationId: updateStartupVariable
+      def set_variable(server, key, value)
+        with_meta("variable",
+                  req("PUT", "#{server_path(server)}/startup/variable", json: { "key" => key, "value" => value }, raw: true))
+      end
+    end
+
+    # Browse and change a server's files (tag Files).
+    class Files < Base
+      # The files and folders in one directory (not paginated). operationId: listFiles
+      def list(server, directory = "/")
+        req("GET", "#{server_path(server)}/files/list", params: { directory: directory })
+      end
+
+      # A file's contents as text (files up to 4 MiB). operationId: getFileContents
+      def read(server, file)
+        req("GET", "#{server_path(server)}/files/contents", params: { file: file }, text: true)
+      end
+
+      # A single-use download link for a file, valid for 15 minutes. operationId: getFileDownloadUrl
+      def download_url(server, file)
+        req("GET", "#{server_path(server)}/files/download", params: { file: file })["url"].to_s
+      end
+
+      # Create or overwrite a file. A String in Encoding::BINARY is sent as binary, any other as text. operationId: writeFile
+      def write(server, file, content)
+        req("POST", "#{server_path(server)}/files/write", params: { file: file }, content: content.to_s)
+      end
+
+      # Rename or move files: files is [["old", "new"]] or [{"from" => ..., "to" => ...}]. operationId: renameFiles
+      def rename(server, files, root: nil)
+        req("PUT", "#{server_path(server)}/files/rename", json: { "root" => root, "files" => pairs(files, "from", "to") })
+      end
+
+      # Copy a file next to itself (main.rb becomes "main copy.rb"). operationId: copyFile
+      def copy(server, location)
+        req("POST", "#{server_path(server)}/files/copy", json: { "location" => location })
+      end
+
+      # Pack files into an archive in root; returns the archive's file object. operationId: compressFiles
+      def compress(server, files, root: nil)
+        req("POST", "#{server_path(server)}/files/compress", json: body(root: root, files: Array(files)))
+      end
+
+      # Unpack an archive into root. operationId: decompressFile
+      def decompress(server, file, root: nil)
+        req("POST", "#{server_path(server)}/files/decompress", json: body(root: root, file: file))
+      end
+
+      # Delete files and folders. operationId: deleteFiles
+      def delete(server, files, root: nil)
+        req("POST", "#{server_path(server)}/files/delete", json: { "root" => root, "files" => Array(files) })
+      end
+
+      # Create a folder in root. operationId: createFolder
+      def create_folder(server, name, root: nil)
+        req("POST", "#{server_path(server)}/files/create-folder", json: body(root: root, name: name))
+      end
+
+      # Change permissions: files is [["main.rb", "644"]] or [{"file" => ..., "mode" => ...}]. operationId: chmodFiles
+      def chmod(server, files, root: nil)
+        req("POST", "#{server_path(server)}/files/chmod", json: { "root" => root, "files" => pairs(files, "file", "mode") })
+      end
+
+      # Have the node download a file from a URL into the server. operationId: pullFile
+      def pull(server, url, directory: nil, filename: nil, use_header: nil, foreground: nil)
+        req("POST", "#{server_path(server)}/files/pull",
+            json: body(url: url, directory: directory, filename: filename, use_header: use_header, foreground: foreground))
+      end
+
+      # A single-use upload link on the node, valid for 15 minutes. operationId: getFileUploadUrl
+      def upload_url(server)
+        req("GET", "#{server_path(server)}/files/upload")["url"].to_s
+      end
+
+      # Whether the files are managed by a linked Git repository. operationId: getFileGitNotice
+      def git_notice(server)
+        req("GET", "#{server_path(server)}/files/git")
+      end
+    end
+
+    # Backups of a server's files (tag Backups).
+    class Backups < Base
+      # Every backup, fetching page after page. operationId: listBackups
+      def list(server, per_page: nil)
+        @client.paginate("#{server_path(server)}/backups", { per_page: per_page })
+      end
+
+      # One page of backups; page.meta["backup_count"] counts those towards the limit. operationId: listBackups
+      def list_page(server, page: 1, per_page: nil)
+        @client.page("#{server_path(server)}/backups", { page: page, per_page: per_page })
+      end
+
+      # Start a backup. ignored is paths to leave out, one per line or as an array. operationId: createBackup
+      def create(server, name: nil, is_locked: nil, ignored: nil)
+        ignored = ignored.join("\n") if ignored.is_a?(Array)
+        req("POST", "#{server_path(server)}/backups", json: body(name: name, is_locked: is_locked, ignored: ignored))
+      end
+
+      # One backup. operationId: getBackup
+      def get(server, backup)
+        req("GET", "#{server_path(server)}/backups/#{seg(backup)}")
+      end
+
+      # Delete an unlocked backup. operationId: deleteBackup
+      def delete(server, backup)
+        req("DELETE", "#{server_path(server)}/backups/#{seg(backup)}")
+      end
+
+      # A single-use download link for a backup, valid for 15 minutes. operationId: getBackupDownloadUrl
+      def download_url(server, backup)
+        req("GET", "#{server_path(server)}/backups/#{seg(backup)}/download")["url"].to_s
+      end
+
+      # Lock an unlocked backup or unlock a locked one. operationId: toggleBackupLock
+      def toggle_lock(server, backup)
+        req("POST", "#{server_path(server)}/backups/#{seg(backup)}/lock")
+      end
+
+      # Restore a backup; truncate: true deletes every file first. operationId: restoreBackup
+      def restore(server, backup, truncate: false)
+        req("POST", "#{server_path(server)}/backups/#{seg(backup)}/restore", json: { "truncate" => truncate })
+      end
+    end
+
+    # Schedules and their tasks (tag Schedules).
+    class Schedules < Base
+      # Every schedule on the server, with its tasks. operationId: listSchedules
+      def list(server)
+        req("GET", "#{server_path(server)}/schedules")
+      end
+
+      # Create a schedule from a cron timetable. operationId: createSchedule
+      def create(server, name:, minute:, hour:, day_of_month:, month:, day_of_week:, is_active: nil, only_when_online: nil)
+        req("POST", "#{server_path(server)}/schedules",
+            json: body(name: name, minute: minute, hour: hour, day_of_month: day_of_month, month: month,
+                       day_of_week: day_of_week, is_active: is_active, only_when_online: only_when_online))
+      end
+
+      # One schedule with its tasks. operationId: getSchedule
+      def get(server, schedule)
+        req("GET", "#{server_path(server)}/schedules/#{seg(schedule)}")
+      end
+
+      # Replace a schedule's name and timetable. operationId: updateSchedule
+      def update(server, schedule, name:, minute:, hour:, day_of_month:, month:, day_of_week:, is_active: nil,
+                 only_when_online: nil)
+        req("POST", "#{server_path(server)}/schedules/#{seg(schedule)}",
+            json: body(name: name, minute: minute, hour: hour, day_of_month: day_of_month, month: month,
+                       day_of_week: day_of_week, is_active: is_active, only_when_online: only_when_online))
+      end
+
+      # Delete a schedule and its tasks. operationId: deleteSchedule
+      def delete(server, schedule)
+        req("DELETE", "#{server_path(server)}/schedules/#{seg(schedule)}")
+      end
+
+      # Run a schedule now. operationId: runSchedule
+      def run(server, schedule)
+        req("POST", "#{server_path(server)}/schedules/#{seg(schedule)}/execute")
+      end
+
+      # Add a task ("command", "power" or "backup") to a schedule. operationId: createScheduleTask
+      def create_task(server, schedule, action:, time_offset:, payload: nil, sequence_id: nil, continue_on_failure: nil)
+        req("POST", "#{server_path(server)}/schedules/#{seg(schedule)}/tasks",
+            json: body(action: action, payload: payload, time_offset: time_offset, sequence_id: sequence_id,
+                       continue_on_failure: continue_on_failure))
+      end
+
+      # Change a task. operationId: updateScheduleTask
+      def update_task(server, schedule, task, action:, time_offset:, payload: nil, sequence_id: nil,
+                      continue_on_failure: nil)
+        req("POST", "#{server_path(server)}/schedules/#{seg(schedule)}/tasks/#{seg(task)}",
+            json: body(action: action, payload: payload, time_offset: time_offset, sequence_id: sequence_id,
+                       continue_on_failure: continue_on_failure))
+      end
+
+      # Remove a task from a schedule. operationId: deleteScheduleTask
+      def delete_task(server, schedule, task)
+        req("DELETE", "#{server_path(server)}/schedules/#{seg(schedule)}/tasks/#{seg(task)}")
+      end
+    end
+
+    # The server's allocations, its IP and port pairs (tag Network).
+    class Network < Base
+      # Every allocation on the server. operationId: listAllocations
+      def list(server)
+        req("GET", "#{server_path(server)}/network/allocations")
+      end
+
+      # Add a port, where an administrator has allowed it. operationId: createAllocation
+      def create(server)
+        req("POST", "#{server_path(server)}/network/allocations")
+      end
+
+      # Set or clear (nil) an allocation's notes. operationId: updateAllocationNotes
+      def set_notes(server, allocation, notes)
+        req("POST", "#{server_path(server)}/network/allocations/#{seg(allocation)}", json: { "notes" => notes })
+      end
+
+      # Remove an allocation that is not the primary one. operationId: deleteAllocation
+      def delete(server, allocation)
+        req("DELETE", "#{server_path(server)}/network/allocations/#{seg(allocation)}")
+      end
+
+      # Make an allocation the primary one. operationId: setPrimaryAllocation
+      def set_primary(server, allocation)
+        req("POST", "#{server_path(server)}/network/allocations/#{seg(allocation)}/primary")
+      end
+    end
+
+    # Other accounts with access to the server (tag Subusers).
+    class Subusers < Base
+      # Every subuser of the server. operationId: listSubusers
+      def list(server)
+        req("GET", "#{server_path(server)}/users")
+      end
+
+      # Invite an account by email with a list of permissions. operationId: createSubuser
+      def create(server, email, permissions)
+        req("POST", "#{server_path(server)}/users", json: { "email" => email, "permissions" => Array(permissions) })
+      end
+
+      # One subuser, by their UUID. operationId: getSubuser
+      def get(server, user)
+        req("GET", "#{server_path(server)}/users/#{seg(user)}")
+      end
+
+      # Replace a subuser's permissions. operationId: updateSubuser
+      def update(server, user, permissions)
+        req("POST", "#{server_path(server)}/users/#{seg(user)}", json: { "permissions" => Array(permissions) })
+      end
+
+      # Remove a subuser. operationId: deleteSubuser
+      def delete(server, user)
+        req("DELETE", "#{server_path(server)}/users/#{seg(user)}")
+      end
+    end
+
+    # Deploy a Git repository into the server's files (tag Git deploys).
+    class Git < Base
+      # The linked repository, its settings and recent deployments. operationId: getGitDeploys
+      def get(server)
+        req("GET", "#{server_path(server)}/git")
+      end
+
+      # Link a repository ("github", "gitlab" or "url" source), or change the link's settings. operationId: linkGitRepository
+      def link(server, source:, repository:, branch:, installation: nil, directory: nil, auto_deploy: nil,
+               restart_on_deploy: nil, start_if_offline: nil, apply_config: nil, sync_startup: nil, write_config: nil)
+        req("PUT", "#{server_path(server)}/git",
+            json: body(source: source, installation: installation, repository: repository, branch: branch,
+                       directory: directory, auto_deploy: auto_deploy, restart_on_deploy: restart_on_deploy,
+                       start_if_offline: start_if_offline, apply_config: apply_config, sync_startup: sync_startup,
+                       write_config: write_config))
+      end
+
+      # Unlink the repository; the files stay. operationId: unlinkGitRepository
+      def unlink(server, delete_config: nil)
+        req("DELETE", "#{server_path(server)}/git", params: { delete_config: delete_config })
+      end
+
+      # Repositories the connected GitHub or GitLab account can deploy: {"data", "errors"}. operationId: listGitRepositories
+      def repositories(server, provider: nil)
+        req("GET", "#{server_path(server)}/git/repositories", params: { provider: provider })
+      end
+
+      # Deploy the linked branch now; returns the queued deployment. operationId: deployGitRepository
+      def deploy(server)
+        req("POST", "#{server_path(server)}/git/deploy")
+      end
+
+      # Cancel a queued or running deployment. operationId: cancelGitDeployment
+      def cancel_deployment(server, deployment)
+        req("POST", "#{server_path(server)}/git/deployments/#{seg(deployment)}/cancel")
+      end
+
+      # A sillydev.conf written from the server's current settings. operationId: getGitConfigTemplate
+      def config_template(server)
+        req("GET", "#{server_path(server)}/git/config")
+      end
+
+      # Commit the server's settings to sillydev.conf in the repository. operationId: syncGitConfig
+      def sync_config(server)
+        req("POST", "#{server_path(server)}/git/config")
+      end
+
+      # The repository's sillydev.conf as the panel's editor shows it. operationId: getGitConfigEditor
+      def config_editor(server)
+        req("GET", "#{server_path(server)}/git/config/editor")
+      end
+
+      # Commit a new sillydev.conf (mode is "form" or "raw"). operationId: saveGitConfigEditor
+      def save_config_editor(server, mode:, sha: nil, raw: nil, variables: nil, image: nil)
+        req("PUT", "#{server_path(server)}/git/config/editor",
+            json: body(mode: mode, sha: sha, raw: raw, variables: variables, image: image))
+      end
+    end
+
+    # The account the key belongs to (tag Account).
+    class Account < Base
+      # The account's details. operationId: getAccount
+      def get
+        req("GET", "/account")
+      end
+
+      # The account's activity log, fetching page after page. operationId: listAccountActivity
+      def activity(event: nil, sort: nil, include: nil, per_page: nil)
+        @client.paginate("/account/activity",
+                         { "filter[event]" => event, sort: sort, include: include, per_page: per_page })
+      end
+
+      # One page of the account's activity log. operationId: listAccountActivity
+      def activity_page(page: 1, per_page: nil, event: nil, sort: nil, include: nil)
+        @client.page("/account/activity",
+                     { page: page, per_page: per_page, "filter[event]" => event, sort: sort, include: include })
+      end
+    end
+
+    # Create free servers (tag Server creation).
+    class ServerCreation < Base
+      # How many free servers the account may create, and the runtimes on offer. operationId: getServerCreationOptions
+      def options
+        req("GET", "/server-creation")
+      end
+
+      # Create a free server ("nodejs", "python" or "bun" runtime). operationId: createServer
+      def create(name:, runtime:, description: nil)
+        req("POST", "/server-creation", json: body(name: name, description: description, runtime: runtime))
+      end
+    end
+
+    # The account's free MariaDB and Postgres databases (tag Databases).
+    class Databases < Base
+      # {"limit", "owned", "can_create", "quota_bytes", "versions", "databases"}. operationId: listDatabases
+      def list
+        req("GET", "/databases")
+      end
+
+      # Create a database; the result holds its password. operationId: createDatabase
+      def create(label:, version_id:)
+        req("POST", "/databases", json: { "label" => label, "version_id" => version_id })
+      end
+
+      # Give the database a new password. operationId: rotateDatabasePassword
+      def rotate_password(database)
+        req("POST", "/databases/#{seg(database)}/rotate-password")
+      end
+
+      # Move the database to another version. operationId: moveDatabase
+      def move(database, version_id:)
+        req("POST", "/databases/#{seg(database)}/move", json: { "version_id" => version_id })
+      end
+
+      # Go back to the version the database was moved from. operationId: undoDatabaseMove
+      def undo_move(database)
+        req("POST", "/databases/#{seg(database)}/undo-move")
+      end
+
+      # Keep a move and drop the old copy. operationId: keepDatabaseMove
+      def keep_move(database)
+        req("POST", "/databases/#{seg(database)}/keep-move")
+      end
+
+      # Delete a database and everything in it. operationId: deleteDatabase
+      def delete(database)
+        req("DELETE", "/databases/#{seg(database)}")
+      end
+    end
+
+    # Paid servers and databases (tag Billing). Prices are in pence.
+    class Billing < Base
+      # The plan, the account's subscriptions and its saved card. operationId: getBilling
+      def get
+        req("GET", "/billing")
+      end
+
+      # Order a new paid server (name: and runtime:) or upgrade a free one (server_uuid:).
+      #
+      # An Idempotency-Key is always sent, so a retried request never buys twice: pass your own
+      # idempotency_key: to make retries across runs safe too. operationId: createCheckout
+      def checkout(name: nil, runtime: nil, description: nil, server_uuid: nil, use_saved_card: nil,
+                   promotion_code: nil, plan: nil, idempotency_key: nil)
+        req("POST", "/billing/checkout",
+            json: body(server_uuid: server_uuid, name: name, description: description, runtime: runtime,
+                       use_saved_card: use_saved_card, promotion_code: promotion_code, plan: plan),
+            headers: { "Idempotency-Key" => idempotency_key || SecureRandom.uuid })
+      end
+
+      # Order a paid database (plan:, label: and version_id:) or put a free one on a paid plan
+      # (plan: and database_id:). An Idempotency-Key is always sent. operationId: createDatabaseCheckout
+      def database_checkout(plan:, database_id: nil, label: nil, version_id: nil, use_saved_card: nil,
+                            promotion_code: nil, idempotency_key: nil)
+        req("POST", "/billing/databases/checkout",
+            json: body(plan: plan, database_id: database_id, label: label, version_id: version_id,
+                       use_saved_card: use_saved_card, promotion_code: promotion_code),
+            headers: { "Idempotency-Key" => idempotency_key || SecureRandom.uuid })
+      end
+
+      # Change a paid database's plan, or pass "free" to end it. operationId: changeDatabasePlan
+      def change_database_plan(database, plan)
+        req("POST", "/billing/databases/#{seg(database)}/plan", json: { "plan" => plan })
+      end
+
+      # Undo a waiting move to a smaller plan, or to free. operationId: keepDatabasePlan
+      def keep_database_plan(database)
+        req("POST", "/billing/databases/#{seg(database)}/plan/keep")
+      end
+
+      # The credit balance and one page (25 entries, newest first) of its activity. view: is
+      # "history" (the default) or "pending". operationId: getAccountCredit
+      def credit(view: nil, page: nil)
+        req("GET", "/billing/credit", params: { view: view, page: page })
+      end
+
+      # Every entry of the credit activity (or pending rewards), fetching each page as it is reached.
+      def credit_entries(view = "history")
+        Enumerator.new do |yielder|
+          number = 1
+          loop do
+            result = credit(view: view, page: number)
+            entries = result["data"] || []
+            entries.each { |entry| yielder << entry }
+            pages = ((result["pagination"] || {})["total_pages"] || 1).to_i
+            break if entries.empty? || number >= pages
+
+            number += 1
+          end
+        end
+      end
+
+      # Move a paid server to another paid plan. A smaller one waits for the next bill unless
+      # when: "now" (refund_to: "card" or "credit"). operationId: changeServerPlan
+      def change_server_plan(server_uuid, plan, when: nil, refund_to: nil)
+        req("POST", "/billing/subscriptions/#{seg(server_uuid)}/plan",
+            json: body(plan: plan, when: binding.local_variable_get(:when), refund_to: refund_to))
+      end
+
+      # Undo a waiting move to a smaller paid plan. operationId: keepServerPlan
+      def keep_server_plan(server_uuid)
+        req("POST", "/billing/subscriptions/#{seg(server_uuid)}/plan/keep")
+      end
+
+      # Cancel an order that has not been paid. operationId: cancelOrder
+      def cancel_order(order_uuid)
+        req("DELETE", "/billing/orders/#{seg(order_uuid)}")
+      end
+
+      # Cancel a server's plan at the end of the period. operationId: cancelSubscription
+      def cancel_subscription(server_uuid)
+        req("POST", "/billing/subscriptions/#{seg(server_uuid)}/cancel")
+      end
+
+      # Undo a cancellation before the period ends. operationId: resumeSubscription
+      def resume_subscription(server_uuid)
+        req("POST", "/billing/subscriptions/#{seg(server_uuid)}/resume")
+      end
+
+      # Move the server back to the free tier now. operationId: cancelSubscriptionImmediately
+      def cancel_subscription_immediately(server_uuid)
+        req("POST", "/billing/subscriptions/#{seg(server_uuid)}/cancel-immediately")
+      end
+    end
+
+    # Application monitoring projects, keys, issues and events (tag Monitoring). This manages
+    # projects; it never sends telemetry.
+    class Monitoring < Base
+      # The account's monitoring projects. operationId: listMonitoringProjects
+      def list_projects
+        req("GET", "/monitoring/projects")
+      end
+
+      # Create a monitoring project. operationId: createMonitoringProject
+      def create_project(name:)
+        req("POST", "/monitoring/projects", json: { "name" => name })
+      end
+
+      # One project, by its UUID. operationId: getMonitoringProject
+      def get_project(project)
+        req("GET", project_path(project))
+      end
+
+      # Rename a project, set the origins its browser keys work on, or change its alerts. operationId: updateMonitoringProject
+      def update_project(project, name: nil, allowed_origins: nil, alerts: nil)
+        req("PATCH", project_path(project),
+            json: body(name: name, allowed_origins: allowed_origins&.to_a, alerts: alerts&.to_h))
+      end
+
+      # Delete a project and all of its data. operationId: deleteMonitoringProject
+      def delete_project(project)
+        req("DELETE", project_path(project))
+      end
+
+      # The project's keys (never their secrets). operationId: listMonitoringKeys
+      def list_keys(project)
+        req("GET", "#{project_path(project)}/keys")
+      end
+
+      # Create a "server" (sdevm_) or "browser" (sdevb_) key. The result's "secret_key" is the key
+      # itself, which is never shown again. operationId: createMonitoringKey
+      def create_key(project, name:, kind: "server")
+        raw = req("POST", "#{project_path(project)}/keys", json: { "name" => name, "kind" => kind }, raw: true)
+        return Envelope.unwrap(raw) unless raw.is_a?(Hash)
+
+        out = Envelope.unwrap(raw.except("meta"))
+        out["secret_key"] = raw["meta"]["secret_key"] if raw["meta"].is_a?(Hash) && raw["meta"].key?("secret_key")
+        out
+      end
+
+      # Revoke a key at once. operationId: deleteMonitoringKey
+      def delete_key(project, key)
+        req("DELETE", "#{project_path(project)}/keys/#{seg(key)}")
+      end
+
+      # Grouped errors: {"data" => [...], "pagination" => {...}}. operationId: listMonitoringIssues
+      def list_issues(project, status: nil, environment: nil, release: nil, q: nil, sort: nil, page: nil, per_page: nil)
+        req("GET", "#{project_path(project)}/issues",
+            params: { status: status, environment: environment, release: release, q: q, sort: sort, page: page,
+                      per_page: per_page })
+      end
+
+      # One issue with its hourly history and latest occurrence. operationId: getMonitoringIssue
+      def get_issue(project, fingerprint)
+        req("GET", "#{project_path(project)}/issues/#{seg(fingerprint)}")
+      end
+
+      # Mark an issue "resolved", "ignored" or "unresolved". operationId: updateMonitoringIssue
+      def update_issue(project, fingerprint, status:)
+        req("PATCH", "#{project_path(project)}/issues/#{seg(fingerprint)}", json: { "status" => status })
+      end
+
+      # Stored occurrences of an issue, newest first. operationId: listMonitoringIssueOccurrences
+      def list_issue_occurrences(project, fingerprint, page: nil, per_page: nil)
+        req("GET", "#{project_path(project)}/issues/#{seg(fingerprint)}/occurrences",
+            params: { page: page, per_page: per_page })
+      end
+
+      # Events, newest first; pass the answer's "next" as before: for older ones. operationId: listMonitoringEvents
+      def list_events(project, range: nil, from: nil, to: nil, name: nil, before: nil, limit: nil)
+        req("GET", "#{project_path(project)}/events",
+            params: { range: range, from: from, to: to, name: name, before: before, limit: limit })
+      end
+
+      # Series, daily quotas and what was dropped today. operationId: getMonitoringUsage
+      def usage(project)
+        req("GET", "#{project_path(project)}/usage")
+      end
+    end
+  end
+
+  # The panel API: client.panel.servers, client.panel.files and the rest.
+  class Panel
+    attr_reader :servers, :settings, :startup, :files, :backups, :schedules, :network, :subusers, :git,
+                :account, :server_creation, :databases, :billing, :monitoring
+
+    def initialize(client)
+      @client = client
+      @servers = Resources::Servers.new(client)
+      @settings = Resources::Settings.new(client)
+      @startup = Resources::Startup.new(client)
+      @files = Resources::Files.new(client)
+      @backups = Resources::Backups.new(client)
+      @schedules = Resources::Schedules.new(client)
+      @network = Resources::Network.new(client)
+      @subusers = Resources::Subusers.new(client)
+      @git = Resources::Git.new(client)
+      @account = Resources::Account.new(client)
+      @server_creation = Resources::ServerCreation.new(client)
+      @databases = Resources::Databases.new(client)
+      @billing = Resources::Billing.new(client)
+      @monitoring = Resources::Monitoring.new(client)
+    end
+
+    # The live console: websocket, streamed, polled or relayed through the panel. Loaded on first
+    # use, so code that never opens a console does not load it.
+    def console
+      @console ||= begin
+        require_relative "console"
+        ConsoleApi.new(@client)
+      end
+    end
+
+    def inspect
+      "#<#{self.class.name}>"
+    end
+  end
+end