feat(cli): show "waking up worker" hint on KEDA cold starts (#167)

Wrap worker-bound commands in block_with_wakeup: show a spinner and, if the
request hasn't returned within ~1.5s, probe the control plane's
/v1/workspaces/<id>/runtime/status and upgrade the message when the worker is
cold. Warm requests pay nothing — the probe only fires after the delay and is
dropped the instant the real response lands. The probe omits X-Workspace-Id so
it reaches the always-warm control plane, not the KEDA interceptor.

Wired into list/get/create/update/delete/refresh across databases, connections,
datasets, tables, context, embedding providers, queries, jobs, indexes, and
query execute. Polling loops, pagination, rayon scans, and internal helpers
stay on plain block().

Co-authored-by: Eddie A Tejeda <669988+eddietejeda@users.noreply.github.com>

Author: eddietejeda

src/connections.rs

@@ -1,4 +1,4 @@
-use crate::sdk::{Api, ApiError, block, none_if_404};
+use crate::sdk::{Api, ApiError, block, block_with_wakeup, none_if_404};
 use serde::{Deserialize, Serialize};
 
 #[derive(Deserialize, Serialize)]
@@ -99,7 +99,12 @@ struct ConnectionTypeDetail {
 
 pub fn types_list(workspace_id: &str, format: &str) {
     let api = Api::new(Some(workspace_id));
-    let resp = block(api.client().connection_types().list()).unwrap_or_else(|e| e.exit());
+    let resp = block_with_wakeup(
+        &api,
+        "Loading connection types…",
+        api.client().connection_types().list(),
+    )
+    .unwrap_or_else(|e| e.exit());
     let body = ListConnectionTypesResponse {
         connection_types: resp
             .connection_types
@@ -136,7 +141,12 @@ pub fn types_list(workspace_id: &str, format: &str) {
 
 pub fn types_get(workspace_id: &str, name: &str, format: &str) {
     let api = Api::new(Some(workspace_id));
-    let resp = block(api.client().connection_types().get(name)).unwrap_or_else(|e| e.exit());
+    let resp = block_with_wakeup(
+        &api,
+        "Loading connection type…",
+        api.client().connection_types().get(name),
+    )
+    .unwrap_or_else(|e| e.exit());
     // The SDK models nullable fields as `Option<Option<Value>>`; flatten and
     // drop an explicit JSON `null` to match the old behavior (the old struct
     // deserialized a missing/`null` field to `None`).
@@ -243,11 +253,18 @@ pub fn get(workspace_id: &str, connection_id: &str, format: &str) {
     let api = Api::new(Some(workspace_id));
     let is_table = format == "table";
 
-    let spinner = is_table.then(|| crate::util::spinner("Fetching connection..."));
-    let resp = block(api.client().connections().get(connection_id)).unwrap_or_else(|e| e.exit());
-    if let Some(s) = spinner {
-        s.finish_and_clear();
+    // Keep the spinner table-only (scripting output stays clean), but route the
+    // interactive path through the wakeup hint so a cold KEDA start is explained.
+    let resp = if is_table {
+        block_with_wakeup(
+            &api,
+            "Fetching connection...",
+            api.client().connections().get(connection_id),
+        )
+    } else {
+        block(api.client().connections().get(connection_id))
     }
+    .unwrap_or_else(|e| e.exit());
     let detail = ConnectionDetail {
         id: resp.id,
         name: resp.name,
@@ -327,16 +344,16 @@ pub fn create(workspace_id: &str, name: &str, source_type: &str, config: &str, f
         source_type.to_string(),
     );
 
-    let spinner = is_table.then(|| crate::util::spinner("Creating connection..."));
-    let resp = block(api.client().connections().create(request)).unwrap_or_else(|e| {
-        if let Some(s) = &spinner {
-            s.finish_and_clear();
-        }
-        e.exit()
-    });
-    if let Some(s) = &spinner {
-        s.finish_and_clear();
+    let resp = if is_table {
+        block_with_wakeup(
+            &api,
+            "Creating connection...",
+            api.client().connections().create(request),
+        )
+    } else {
+        block(api.client().connections().create(request))
     }
+    .unwrap_or_else(|e| e.exit());
 
     let result = CreateResponse {
         id: resp.id,
@@ -404,7 +421,12 @@ pub fn create(workspace_id: &str, name: &str, source_type: &str, config: &str, f
 
 pub fn list(workspace_id: &str, format: &str) {
     let api = Api::new(Some(workspace_id));
-    let resp = block(api.client().connections().list()).unwrap_or_else(|e| e.exit());
+    let resp = block_with_wakeup(
+        &api,
+        "Loading connections…",
+        api.client().connections().list(),
+    )
+    .unwrap_or_else(|e| e.exit());
     let body = ListResponse {
         connections: resp
             .connections

src/connections_new.rs

@@ -2,7 +2,7 @@ use inquire::validator::Validation;
 use inquire::{Confirm, Password, Select, Text};
 use serde_json::{Map, Number, Value};
 
-use crate::sdk::{Api, ApiError, block};
+use crate::sdk::{Api, ApiError, block, block_with_wakeup};
 
 // ── SDK helpers ─────────────────────────────────────────────────────────────
 
@@ -326,9 +326,11 @@ pub fn run(workspace_id: &str) {
         }
     }
 
-    let create_spinner = crate::util::spinner("Creating connection...");
-    let result = block(api.client().connections().create(request));
-    create_spinner.finish_and_clear();
+    let result = block_with_wakeup(
+        &api,
+        "Creating connection...",
+        api.client().connections().create(request),
+    );
 
     use crossterm::style::Stylize;
     let result = match result {

src/context.rs

@@ -131,8 +131,12 @@ fn fetch_context(api: &Api, database_id: &str, name: &str) -> Option<DatabaseCon
 
 pub fn list(workspace_id: &str, database_id: &str, prefix: Option<&str>, format: &str) {
     let api = Api::new(Some(workspace_id));
-    let body = crate::sdk::block(api.client().database_context().list(database_id))
-        .unwrap_or_else(|e| e.exit());
+    let body = crate::sdk::block_with_wakeup(
+        &api,
+        "Loading context…",
+        api.client().database_context().list(database_id),
+    )
+    .unwrap_or_else(|e| e.exit());
 
     let mut rows: Vec<ContextRow> = body.contexts.into_iter().map(ContextRow::from).collect();
     if let Some(p) = prefix {
@@ -295,8 +299,11 @@ pub fn push(workspace_id: &str, database_id: &str, name: &str, dry_run: bool) {
 
     let api = Api::new(Some(workspace_id));
     let request = UpsertDatabaseContextRequest::new(content, name.clone());
-    let resp = match crate::sdk::block(api.client().database_context().upsert(database_id, request))
-    {
+    let resp = match crate::sdk::block_with_wakeup(
+        &api,
+        "Pushing context…",
+        api.client().database_context().upsert(database_id, request),
+    ) {
         Ok(resp) => resp,
         Err(ApiError::Status { status: _, body }) => {
             let msg = crate::util::api_error(body);

src/databases.rs

@@ -1,4 +1,4 @@
-use crate::sdk::{Api, ApiError, block, none_if_404};
+use crate::sdk::{Api, ApiError, block, block_with_wakeup, none_if_404};
 use indicatif::{ProgressBar, ProgressStyle};
 use serde::{Deserialize, Serialize};
 use std::path::Path;
@@ -139,8 +139,12 @@ pub(crate) fn get_database(api: &Api, id: &str) -> Result<Database, ApiError> {
 
 /// List databases through the SDK's typed `databases().list` handle, mapped
 /// into the CLI's summary rows.
+///
+/// Routed through [`block_with_wakeup`] so a cold KEDA start surfaces a "waking
+/// up worker" hint instead of an unexplained pause — `databases list` is a
+/// common first command against an idle workspace.
 fn list_database_summaries(api: &Api) -> Result<Vec<DatabaseSummary>, ApiError> {
-    block(api.client().databases().list())
+    block_with_wakeup(api, "Loading databases…", api.client().databases().list())
         .map(|r| r.databases.into_iter().map(DatabaseSummary::from).collect())
 }
 
@@ -678,16 +682,16 @@ pub fn create(
     let request = create_database_typed_request(name, catalog, schema, tables, expires_at);
 
     let api = Api::new(Some(workspace_id));
-    let spinner = (format == "table").then(|| crate::util::spinner("Creating database..."));
-    let resp = block(api.client().databases().create(request)).unwrap_or_else(|e| {
-        if let Some(s) = &spinner {
-            s.finish_and_clear();
-        }
-        e.exit()
-    });
-    if let Some(s) = &spinner {
-        s.finish_and_clear();
+    let resp = if format == "table" {
+        block_with_wakeup(
+            &api,
+            "Creating database...",
+            api.client().databases().create(request),
+        )
+    } else {
+        block(api.client().databases().create(request))
     }
+    .unwrap_or_else(|e| e.exit());
 
     let result = CreateDatabaseResponse {
         id: resp.id,
@@ -794,7 +798,12 @@ pub fn delete(workspace_id: &str, id_or_name: &str) {
 
     let api = Api::new(Some(workspace_id));
     let db = resolve_database(&api, id_or_name);
-    block(api.client().databases().delete(&db.id)).unwrap_or_else(|e| e.exit());
+    block_with_wakeup(
+        &api,
+        "Deleting database…",
+        api.client().databases().delete(&db.id),
+    )
+    .unwrap_or_else(|e| e.exit());
 
     // If the deleted database was the current one, clear it so subsequent
     // commands don't silently send a stale X-Database-Id header.

src/datasets.rs

@@ -158,7 +158,9 @@ pub fn create_from_saved_query(
 pub fn list(workspace_id: &str, limit: Option<u32>, offset: Option<u32>, format: &str) {
     let api = Api::new(Some(workspace_id));
 
-    let body = crate::sdk::block(
+    let body = crate::sdk::block_with_wakeup(
+        &api,
+        "Loading datasets…",
         api.client()
             .datasets()
             .list(limit.map(|l| l as i32), offset.map(|o| o as i32)),
@@ -219,8 +221,12 @@ pub fn list(workspace_id: &str, limit: Option<u32>, offset: Option<u32>, format:
 pub fn get(dataset_id: &str, workspace_id: &str, format: &str) {
     let api = Api::new(Some(workspace_id));
 
-    let resp: GetDatasetResponse =
-        crate::sdk::block(api.client().datasets().get(dataset_id)).unwrap_or_else(|e| e.exit());
+    let resp: GetDatasetResponse = crate::sdk::block_with_wakeup(
+        &api,
+        "Loading dataset…",
+        api.client().datasets().get(dataset_id),
+    )
+    .unwrap_or_else(|e| e.exit());
 
     let d = DatasetDetail {
         id: resp.id,
@@ -295,9 +301,12 @@ pub fn update(
         request.table_name = Some(Some(n.to_string()));
     }
 
-    let resp: UpdateDatasetResponse =
-        crate::sdk::block(api.client().datasets().update(dataset_id, request))
-            .unwrap_or_else(|e| e.exit());
+    let resp: UpdateDatasetResponse = crate::sdk::block_with_wakeup(
+        &api,
+        "Updating dataset…",
+        api.client().datasets().update(dataset_id, request),
+    )
+    .unwrap_or_else(|e| e.exit());
     let d = UpdateView::from(resp);
 
     use crossterm::style::Stylize;
@@ -341,8 +350,12 @@ pub fn refresh(workspace_id: &str, dataset_id: &str, async_mode: bool) {
         request.r#async = Some(true);
     }
 
-    let resp =
-        crate::sdk::block(api.client().refresh().refresh(request)).unwrap_or_else(|e| e.exit());
+    let resp = crate::sdk::block_with_wakeup(
+        &api,
+        "Refreshing dataset…",
+        api.client().refresh().refresh(request),
+    )
+    .unwrap_or_else(|e| e.exit());
 
     if async_mode {
         let job_id = match &resp {

src/embedding_providers.rs

@@ -44,12 +44,16 @@ fn parse_config(raw: Option<&str>) -> Option<serde_json::Value> {
 
 pub fn list(workspace_id: &str, format: &str) {
     let api = Api::new(Some(workspace_id));
-    let providers: Vec<Provider> = crate::sdk::block(api.client().embedding_providers().list())
-        .unwrap_or_else(|e| e.exit())
-        .embedding_providers
-        .into_iter()
-        .map(Provider::from)
-        .collect();
+    let providers: Vec<Provider> = crate::sdk::block_with_wakeup(
+        &api,
+        "Loading embedding providers…",
+        api.client().embedding_providers().list(),
+    )
+    .unwrap_or_else(|e| e.exit())
+    .embedding_providers
+    .into_iter()
+    .map(Provider::from)
+    .collect();
 
     use crossterm::style::Stylize;
     match format {
@@ -80,9 +84,13 @@ pub fn list(workspace_id: &str, format: &str) {
 
 pub fn get(workspace_id: &str, id: &str, format: &str) {
     let api = Api::new(Some(workspace_id));
-    let p: Provider = crate::sdk::block(api.client().embedding_providers().get(id))
-        .unwrap_or_else(|e| e.exit())
-        .into();
+    let p: Provider = crate::sdk::block_with_wakeup(
+        &api,
+        "Loading embedding provider…",
+        api.client().embedding_providers().get(id),
+    )
+    .unwrap_or_else(|e| e.exit())
+    .into();
 
     match format {
         "json" => println!("{}", serde_json::to_string_pretty(&p).unwrap()),
@@ -128,8 +136,12 @@ pub fn create(
         req.secret_name = Some(Some(s.to_string()));
     }
 
-    let resp = crate::sdk::block(api.client().embedding_providers().create(req))
-        .unwrap_or_else(|e| e.exit());
+    let resp = crate::sdk::block_with_wakeup(
+        &api,
+        "Creating embedding provider…",
+        api.client().embedding_providers().create(req),
+    )
+    .unwrap_or_else(|e| e.exit());
     let parsed = serde_json::to_value(&resp).unwrap_or_default();
 
     eprintln!("{}", "Embedding provider created.".green());
@@ -180,8 +192,12 @@ pub fn update(
         req.secret_name = Some(Some(s.to_string()));
     }
 
-    let resp = crate::sdk::block(api.client().embedding_providers().update(id, req))
-        .unwrap_or_else(|e| e.exit());
+    let resp = crate::sdk::block_with_wakeup(
+        &api,
+        "Updating embedding provider…",
+        api.client().embedding_providers().update(id, req),
+    )
+    .unwrap_or_else(|e| e.exit());
     let resp = serde_json::to_value(&resp).unwrap_or_default();
 
     eprintln!("{}", "Embedding provider updated.".green());
@@ -202,7 +218,12 @@ pub fn update(
 pub fn delete(workspace_id: &str, id: &str) {
     use crossterm::style::Stylize;
     let api = Api::new(Some(workspace_id));
-    crate::sdk::block(api.client().embedding_providers().delete(id)).unwrap_or_else(|e| e.exit());
+    crate::sdk::block_with_wakeup(
+        &api,
+        "Deleting embedding provider…",
+        api.client().embedding_providers().delete(id),
+    )
+    .unwrap_or_else(|e| e.exit());
     println!("{}", format!("Embedding provider '{id}' deleted.").green());
 }
 

src/indexes.rs

@@ -1,4 +1,4 @@
-use crate::sdk::{Api, block, none_if_404};
+use crate::sdk::{Api, block, block_with_wakeup, none_if_404};
 use rayon::prelude::*;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
@@ -548,12 +548,16 @@ pub fn delete(workspace_id: &str, scope: IndexScope<'_>, index_name: &str) {
             connection_id,
             schema,
             table,
-        } => block(
+        } => block_with_wakeup(
+            &api,
+            "Deleting index…",
             api.client()
                 .indexes()
                 .delete_index(connection_id, schema, table, index_name),
         ),
-        IndexScope::Dataset { dataset_id } => block(
+        IndexScope::Dataset { dataset_id } => block_with_wakeup(
+            &api,
+            "Deleting index…",
             api.client()
                 .indexes()
                 .delete_dataset_index(dataset_id, index_name),

src/jobs.rs

@@ -49,9 +49,10 @@ fn parse_job_type(s: &str) -> Option<JobType> {
 
 pub fn get(job_id: &str, workspace_id: &str, format: &str) {
     let api = Api::new(Some(workspace_id));
-    let job: Job = crate::sdk::block(api.client().jobs().get(job_id))
-        .unwrap_or_else(|e| e.exit())
-        .into();
+    let job: Job =
+        crate::sdk::block_with_wakeup(&api, "Loading job…", api.client().jobs().get(job_id))
+            .unwrap_or_else(|e| e.exit())
+            .into();
 
     match format {
         "json" => println!("{}", serde_json::to_string_pretty(&job).unwrap()),