feat: add incidents, logs, SQL query API, and CLI improvements (Phase 2) (#10)

Incidents:
- Add `bs incidents list/get/create/ack/resolve/escalate/delete/timeline`
- Full CRUD and lifecycle management via Uptime API v2/v3

Logs & SQL Query API:
- Add `bs logs sources` and `bs logs source <id>` for source management
- Add `bs logs query` with filter-to-SQL compiler supporting field
  comparisons (>=, <=, >, <), wildcards, quoted contains, AND/OR
- Add `bs logs tail` with two-phase polling (historical dump + live),
  Ctrl+C handling, and colored pretty-print output
- Add `bs logs sql` for raw ClickHouse SQL queries
- SQL Query API integration with auto-provisioning of connections
  and interactive credential setup in `bs auth init`
- Parse raw JSON from SQL results: table mode shows dt/level/message,
  JSON mode outputs parsed objects, CSV extracts fields
- Query compiler uses top-level JSON fields only (configure VRL
  transforms on sources for field mapping)

Auth:
- Add SQL credential prompts (host, username, password) to `bs auth init`
- Show SQL connection status in `bs auth status`
- Add Telemetry API token support

Output:
- Terminal-width-aware unicode-safe table rendering with proportional
  column sizing using `unicode-width` crate
- Color level cells in table output (red=ERROR, yellow=WARN, green=INFO)
- Dim timestamps in log output
- Convert UTC timestamps to local time
- Add `CommandOutput::Raw` variant for pre-formatted output
- Status coloring for incidents (started/acknowledged/resolved)

UX:
- Add `arg_required_else_help` across all subcommands
- Show help pages for bare subcommands instead of errors
- Fix SQL client to not append LIMIT/FORMAT to non-SELECT queries
- Add monitor expand/create/pause/resume/update/delete commands

Author: sounak98

Cargo.lock

@@ -18,8 +18,9 @@ reqwest = { version = "0.12", default-features = false, features = ["json", "rus
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 tempfile = "3"
-tokio = { version = "1", features = ["rt-multi-thread", "macros"] }
+tokio = { version = "1", features = ["rt-multi-thread", "macros", "signal"] }
 toml = "1.0"
+unicode-width = "0.2"
 
 [dev-dependencies]
 wiremock = "0.6"

Cargo.toml

@@ -16,11 +16,11 @@ pub struct AuthConfig {
     pub sql: Option<SqlAuthConfig>,
 }
 
-#[derive(Debug, Default, Serialize, Deserialize)]
+#[derive(Debug, Default, Clone, Serialize, Deserialize)]
 pub struct SqlAuthConfig {
+    pub host: Option<String>,
     pub username: Option<String>,
     pub password: Option<String>,
-    pub region: Option<String>,
 }
 
 #[derive(Debug, Default, Serialize, Deserialize)]

src/adapters/config/schema.rs

@@ -0,0 +1,64 @@
+use anyhow::{Result, bail};
+use serde::Deserialize;
+
+use super::HttpClient;
+use super::retry::with_retry;
+
+#[derive(Debug, Deserialize)]
+struct ConnectionResponse {
+    data: ConnectionData,
+}
+
+#[derive(Debug, Deserialize)]
+struct ConnectionData {
+    attributes: ConnectionAttributes,
+}
+
+#[derive(Debug, Deserialize)]
+struct ConnectionAttributes {
+    host: Option<String>,
+    username: Option<String>,
+    password: Option<String>,
+}
+
+pub struct ConnectionCredentials {
+    pub host: String,
+    pub username: String,
+    pub password: String,
+}
+
+impl HttpClient {
+    pub async fn create_sql_connection(&self) -> Result<ConnectionCredentials> {
+        let body = serde_json::json!({
+            "client_type": "clickhouse"
+        });
+
+        let resp = with_retry(|| async { Ok(self.post("/connections").json(&body).send().await?) })
+            .await?;
+
+        let status = resp.status();
+        if !status.is_success() {
+            let body = resp.text().await.unwrap_or_default();
+            bail!("Failed to create SQL connection ({}): {}", status, body);
+        }
+
+        let parsed: ConnectionResponse = resp.json().await?;
+        let attrs = parsed.data.attributes;
+
+        let host = attrs
+            .host
+            .ok_or_else(|| anyhow::anyhow!("No host in connection response"))?;
+        let username = attrs
+            .username
+            .ok_or_else(|| anyhow::anyhow!("No username in connection response"))?;
+        let password = attrs
+            .password
+            .ok_or_else(|| anyhow::anyhow!("No password in connection response"))?;
+
+        Ok(ConnectionCredentials {
+            host,
+            username,
+            password,
+        })
+    }
+}

src/adapters/http/connections.rs

@@ -1,3 +1,4 @@
+pub mod connections;
 pub mod incidents;
 pub mod pagination;
 pub mod retry;

src/adapters/http/mod.rs

@@ -10,8 +10,12 @@ pub struct SqlClient {
 }
 
 impl SqlClient {
-    pub fn new(region: &str, username: &str, password: &str) -> Self {
-        let base_url = format!("https://{region}-connect.betterstackdata.com");
+    pub fn new(host: &str, username: &str, password: &str) -> Self {
+        let base_url = if host.starts_with("https://") {
+            host.to_string()
+        } else {
+            format!("https://{host}")
+        };
         Self {
             client: reqwest::Client::new(),
             base_url,
@@ -22,14 +26,23 @@ impl SqlClient {
 
     pub async fn query(&self, sql: &str) -> Result<String> {
         let url = &self.base_url;
-        let resp = with_retry(|| async {
-            Ok(self
-                .client
-                .post(url)
-                .basic_auth(&self.username, Some(&self.password))
-                .body(format!("{sql} FORMAT JSONEachRow"))
-                .send()
-                .await?)
+        let is_select = sql.trim_start().to_uppercase().starts_with("SELECT");
+        let body = if is_select {
+            format!("{sql} FORMAT JSONEachRow")
+        } else {
+            sql.to_string()
+        };
+        let resp = with_retry(|| {
+            let body = body.clone();
+            async move {
+                Ok(self
+                    .client
+                    .post(url)
+                    .basic_auth(&self.username, Some(&self.password))
+                    .body(body)
+                    .send()
+                    .await?)
+            }
         })
         .await?;