restate up command

A developer-focused version of restate that's embedded into the restate CLI. It starts restate on an ephemeral temporary directory that's auto-deleted after Ctrl+C.
1. Supports --use-random-ports
2. Emits very clean output, it doesn't show the server log. Just a table of addresses.
3. Opens the admin UI automatically on startup in the browser
4. Runs the Counter service on a random port and auto-registers it by default so you can play with the UI immediately with that service.
5. Supports --retain to persist the temporary directory (meant to be used in debugging) and currently it doesn't support choosing your own directory

Author: AhmedSoliman

Cargo.lock

@@ -17,7 +17,8 @@ dist = true
 formula = "restate"
 
 [features]
-default = ["cloud", "no-trace-logging"]
+default = ["cloud", "no-trace-logging", "dev-cmd"]
+dev-cmd = ["restate-lite", "mock-service-endpoint"]
 cloud = []
 no-trace-logging = ["tracing/max_level_trace", "tracing/release_max_level_debug"]
 
@@ -30,6 +31,8 @@ restate-cloud-tunnel-client = { workspace = true }
 restate-serde-util = { workspace = true }
 restate-time-util = { workspace = true }
 restate-types = { workspace = true }
+restate-lite = { workspace = true, optional = true }
+mock-service-endpoint = { workspace = true, optional = true }
 
 anyhow = { workspace = true }
 arc-swap = { workspace = true }

cli/Cargo.toml

@@ -49,6 +49,10 @@ pub struct GlobalOpts {
 
 #[derive(Run, Subcommand, Clone)]
 pub enum Command {
+    #[cfg(feature = "dev-cmd")]
+    #[clap(name = "dev", visible_alias = "up")]
+    Dev(dev::Dev),
+
     /// Prints general information about the configured environment
     #[clap(name = "whoami")]
     WhoAmI(whoami::WhoAmI),

cli/src/app.rs

@@ -4,15 +4,18 @@
 // Use of this software is governed by the Business Source License
 // included in the LICENSE file.
 //
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
+// As of the Change Date specified in that file, in accordance with the Business Source License, use of this software will be governed
 // by the Apache License, Version 2.0.
 
 //! Build information
 #![allow(dead_code)]
 
+use std::str::FromStr;
 use std::sync::OnceLock;
 
+use restate_cli_util::c_println;
+use restate_types::SemanticRestateVersion;
+
 /// The version of restate CLI.
 pub const RESTATE_CLI_VERSION: &str = env!("CARGO_PKG_VERSION");
 pub const RESTATE_CLI_VERSION_MAJOR: &str = env!("CARGO_PKG_VERSION_MAJOR");
@@ -51,3 +54,40 @@ const RESTATE_CLI_DEBUG: &str = env!("VERGEN_CARGO_DEBUG");
 pub fn is_debug() -> bool {
     RESTATE_CLI_DEBUG == "true" && RESTATE_CLI_DEBUG_STRIPPED != Some("true")
 }
+
+pub async fn check_if_latest_version() {
+    let octocrab = octocrab::instance();
+    let Ok(mut latest) = octocrab
+        .repos("restatedev", "restate")
+        .releases()
+        .get_latest()
+        .await
+    else {
+        return;
+    };
+
+    let current_version = SemanticRestateVersion::current().clone();
+    if latest.tag_name.starts_with("v") {
+        // ignore if the tag is not a version
+        let version_str = latest.tag_name.split_off(1);
+        let Ok(latest_release) = SemanticRestateVersion::from_str(&version_str) else {
+            return;
+        };
+
+        if matches!(
+            latest_release.cmp_precedence(&current_version),
+            std::cmp::Ordering::Greater
+        ) {
+            c_println!(
+                "📣⬆️A newer version was released at {}, v{}->v{}. Check it out at {}.",
+                current_version.to_string(),
+                latest_release.to_string(),
+                latest
+                    .published_at
+                    .map(|d| d.to_string())
+                    .unwrap_or("<unknown>".to_owned()),
+                latest.html_url.to_string()
+            );
+        }
+    }
+}

cli/src/build_info.rs

@@ -0,0 +1,150 @@
+// Copyright (c) 2023 - 2025 Restate Software, Inc., Restate GmbH.
+// All rights reserved.
+//
+// Use of this software is governed by the Business Source License
+// included in the LICENSE file.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0.
+
+use anyhow::{Result, anyhow};
+use cling::prelude::*;
+use comfy_table::{Cell, Table};
+use tokio::net::TcpListener;
+use tokio::sync::oneshot;
+use tokio_util::sync::CancellationToken;
+
+use restate_cli_util::ui::console::StyledTable;
+use restate_cli_util::ui::stylesheet;
+use restate_cli_util::{CliContext, c_indent_table, c_println};
+use restate_lite::{AddressMeta, Options, Restate};
+use restate_types::art::render_restate_logo;
+use restate_types::net::address::{AdminPort, HttpIngressPort, ListenerPort};
+
+use crate::build_info;
+use crate::cli_env::CliEnv;
+
+#[derive(Run, Parser, Collect, Clone)]
+#[cling(run = "run")]
+pub struct Dev {
+    /// Start restate on a set of random ports
+    #[clap(long, short = 'r')]
+    use_random_ports: bool,
+
+    /// Start restate on unix sockets only
+    #[clap(long, short = 'u')]
+    use_unix_sockets: bool,
+
+    /// Do not delete the temporary data directory after exiting
+    #[clap(long)]
+    retain: bool,
+}
+
+pub async fn run(State(_env): State<CliEnv>, opts: &Dev) -> Result<()> {
+    let cancellation = CancellationToken::new();
+    let temp_dir = tempfile::tempdir()?;
+    let data_dir = temp_dir.path().to_path_buf();
+
+    let options = Options {
+        enable_tcp: !opts.use_unix_sockets,
+        use_random_ports: opts.use_random_ports,
+        data_dir: Some(data_dir.clone()),
+        ..Default::default()
+    };
+
+    let listener = TcpListener::bind("127.0.0.1:0").await?;
+    let mock_svc_addr = format!("http://{}/", listener.local_addr()?);
+
+    let (running_tx, running_rx) = oneshot::channel();
+    tokio::spawn({
+        let cancellation = cancellation.clone();
+        async move {
+            cancellation
+                .run_until_cancelled(mock_service_endpoint::listener::run_listener(
+                    listener,
+                    || {
+                        let _ = running_tx.send(());
+                    },
+                ))
+                .await
+                .map(|result| result.map_err(|err| anyhow!("mock service endpoint failed: {err}")))
+                .unwrap_or(Ok(()))
+        }
+    });
+
+    let _ = running_rx.await;
+
+    if opts.retain {
+        c_println!(
+            "{} Data directory will be retained after exit",
+            stylesheet::HANDSHAKE_ICON
+        );
+        let _ = temp_dir.keep();
+    }
+
+    {
+        let cancellation = cancellation.clone();
+        let boxed: Box<dyn Fn() + Send> = Box::new(move || cancellation.cancel());
+        *crate::EXIT_HANDLER.lock().unwrap() = Some(boxed);
+    }
+
+    let restate = Restate::create(options).await?;
+    // register mock service
+    if let Err(err) = restate.discover_deployment(&mock_svc_addr).await {
+        // we'll print this but we'll continue anyway since this is not a catastrophic error
+        // for the user.
+        eprintln!("Failed to discover the example `Counter` service deployment: {err:#?}");
+    }
+
+    let addresses = restate.get_advertised_addresses();
+
+    let admin_url = addresses
+        .iter()
+        .find_map(|address| {
+            if address.name == AdminPort::NAME {
+                Some(address.address.clone())
+            } else {
+                None
+            }
+        })
+        .expect("Admin port is always set");
+    c_println!(">> Using data dir: {}", data_dir.display());
+    render(&addresses);
+    c_println!();
+    c_println!("✅ `Counter` service endpoint is running on {mock_svc_addr}");
+
+    if let Err(_err) = open::that(&admin_url) {
+        c_println!("Failed to open browser automatically. Please open {admin_url} manually.")
+    }
+
+    c_println!();
+    c_println!(
+        "{} Restate is running - Press Ctrl-C to exit",
+        stylesheet::TIP_ICON
+    );
+    c_println!();
+    // spawn checking latest release
+    tokio::spawn(build_info::check_if_latest_version());
+    cancellation.cancelled().await;
+
+    restate.stop().await?;
+    Ok(())
+}
+
+fn render(addresses: &[AddressMeta]) {
+    let mut table = Table::new_styled();
+    let logo = render_restate_logo(CliContext::get().colors_enabled());
+    c_println!("{}", logo);
+
+    for address in addresses {
+        if [HttpIngressPort::NAME, AdminPort::NAME].contains(&address.name.as_str()) {
+            table.add_row(vec![
+                Cell::new(address.name.to_string()).add_attribute(comfy_table::Attribute::Bold),
+                Cell::new(address.address.to_string()),
+            ]);
+        }
+    }
+
+    c_indent_table!(0, table);
+}

cli/src/commands/dev.rs

@@ -13,6 +13,8 @@ pub mod cloud;
 pub mod completions;
 pub mod config;
 pub mod deployments;
+#[cfg(feature = "dev-cmd")]
+pub mod dev;
 pub mod examples;
 pub mod invocations;
 pub mod services;