Add users command for bootstrap user creation

Enables self-hosted deployments to create the first user without
requiring an existing user context. Users can now run:
  ow local users create admin

This resolves the chicken-and-egg problem where DB aliases required
a --user flag but there was no way to create users via CLI.

Bumps version to 0.2.2.

Author: max-lt

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "openworkers-cli"
-version = "0.2.1"
+version = "0.2.2"
 edition = "2024"
 license = "MIT"
 

Cargo.toml

@@ -27,6 +27,7 @@ ow workers deploy my-api worker.ts
 | `storage`   | `s`   | S3/R2 storage configurations   |
 | `kv`        | `k`   | Key-value namespaces           |
 | `databases` | `d`   | SQL database bindings          |
+| `users`     | `u`   | User management (DB only)      |
 | `alias`     |       | Backend connection aliases     |
 | `login`     |       | Authenticate with API          |
 | `migrate`   |       | Database schema migrations     |

README.md

@@ -5,4 +5,5 @@ pub mod kv;
 pub mod login;
 pub mod migrate;
 pub mod storage;
+pub mod users;
 pub mod workers;

src/commands/mod.rs

@@ -0,0 +1,229 @@
+use crate::config::{AliasConfig, Config, ConfigError};
+use clap::Subcommand;
+use colored::Colorize;
+use sqlx::postgres::PgPoolOptions;
+use sqlx::{PgPool, Row};
+
+#[derive(Debug, thiserror::Error)]
+pub enum UsersError {
+    #[error("Config error: {0}")]
+    Config(#[from] ConfigError),
+
+    #[error("Database error: {0}")]
+    Sqlx(#[from] sqlx::Error),
+
+    #[error("Alias '{0}' is not a database alias. Use --db when creating the alias.")]
+    NotDbAlias(String),
+
+    #[error("No alias specified and no default alias configured")]
+    NoAlias,
+
+    #[error("User '{0}' not found")]
+    UserNotFound(String),
+
+    #[error("User '{0}' already exists")]
+    UserExists(String),
+}
+
+#[derive(Subcommand)]
+pub enum UsersCommand {
+    /// List all users
+    #[command(alias = "ls", after_help = "Example:\n  ow local users list")]
+    List,
+
+    /// Show user details
+    #[command(after_help = "Example:\n  ow local users get admin")]
+    Get {
+        /// Username
+        username: String,
+    },
+
+    /// Create a new user (bootstrap mode - no user required)
+    #[command(after_help = "Examples:\n  \
+        ow local users create admin\n  \
+        ow local users create max")]
+    Create {
+        /// Username for the new user
+        username: String,
+    },
+
+    /// Delete a user
+    #[command(alias = "rm", after_help = "Example:\n  ow local users delete old-user")]
+    Delete {
+        /// Username to delete
+        username: String,
+    },
+}
+
+impl UsersCommand {
+    pub async fn run(self, alias: Option<String>) -> Result<(), UsersError> {
+        let database_url = resolve_database_url(alias)?;
+        let pool = connect(&database_url).await?;
+
+        match self {
+            Self::List => cmd_list(&pool).await,
+            Self::Get { username } => cmd_get(&pool, &username).await,
+            Self::Create { username } => cmd_create(&pool, username).await,
+            Self::Delete { username } => cmd_delete(&pool, &username).await,
+        }
+    }
+}
+
+fn resolve_database_url(alias: Option<String>) -> Result<String, UsersError> {
+    let config = Config::load()?;
+
+    let alias_name = alias
+        .or(config.default.clone())
+        .ok_or(UsersError::NoAlias)?;
+
+    let alias_config = config
+        .get_alias(&alias_name)
+        .ok_or_else(|| ConfigError::AliasNotFound(alias_name.clone()))?;
+
+    match alias_config {
+        AliasConfig::Db { database_url, .. } => Ok(database_url.clone()),
+        AliasConfig::Api { .. } => Err(UsersError::NotDbAlias(alias_name)),
+    }
+}
+
+async fn connect(database_url: &str) -> Result<PgPool, UsersError> {
+    let pool = PgPoolOptions::new()
+        .max_connections(1)
+        .connect(database_url)
+        .await?;
+
+    Ok(pool)
+}
+
+async fn cmd_list(pool: &PgPool) -> Result<(), UsersError> {
+    let rows = sqlx::query(
+        r#"
+        SELECT id, username, created_at
+        FROM users
+        ORDER BY created_at
+        "#,
+    )
+    .fetch_all(pool)
+    .await?;
+
+    if rows.is_empty() {
+        println!("No users found.");
+        return Ok(());
+    }
+
+    println!("{}", "Users".bold());
+    println!("{}", "─".repeat(60));
+
+    for row in rows {
+        let username: String = row.get("username");
+        let id: uuid::Uuid = row.get("id");
+        let created_at: chrono::NaiveDateTime = row.get("created_at");
+
+        println!(
+            "  {} {} {}",
+            username.bold(),
+            format!("({})", id).dimmed(),
+            format!("created {}", created_at.format("%Y-%m-%d")).dimmed()
+        );
+    }
+
+    Ok(())
+}
+
+async fn cmd_get(pool: &PgPool, username: &str) -> Result<(), UsersError> {
+    let row = sqlx::query(
+        r#"
+        SELECT id, username, created_at, updated_at
+        FROM users
+        WHERE username = $1
+        "#,
+    )
+    .bind(username)
+    .fetch_optional(pool)
+    .await?
+    .ok_or_else(|| UsersError::UserNotFound(username.to_string()))?;
+
+    let id: uuid::Uuid = row.get("id");
+    let username: String = row.get("username");
+    let created_at: chrono::NaiveDateTime = row.get("created_at");
+    let updated_at: chrono::NaiveDateTime = row.get("updated_at");
+
+    println!("{:12} {}", "Username:".dimmed(), username.bold());
+    println!("{:12} {}", "ID:".dimmed(), id);
+    println!(
+        "{:12} {}",
+        "Created:".dimmed(),
+        created_at.format("%Y-%m-%d %H:%M:%S")
+    );
+    println!(
+        "{:12} {}",
+        "Updated:".dimmed(),
+        updated_at.format("%Y-%m-%d %H:%M:%S")
+    );
+
+    Ok(())
+}
+
+async fn cmd_create(pool: &PgPool, username: String) -> Result<(), UsersError> {
+    // Check if user already exists
+    let exists: bool =
+        sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM users WHERE username = $1)")
+            .bind(&username)
+            .fetch_one(pool)
+            .await?;
+
+    if exists {
+        return Err(UsersError::UserExists(username));
+    }
+
+    // Insert new user
+    let row = sqlx::query(
+        r#"
+        INSERT INTO users (username)
+        VALUES ($1)
+        RETURNING id, username, created_at
+        "#,
+    )
+    .bind(&username)
+    .fetch_one(pool)
+    .await?;
+
+    let id: uuid::Uuid = row.get("id");
+
+    println!(
+        "{} User '{}' created (ID: {}).",
+        "Created".green().bold(),
+        username.bold(),
+        id.to_string().dimmed()
+    );
+
+    println!(
+        "\n{} Set this user as default with:",
+        "Next:".cyan().bold()
+    );
+    println!(
+        "  {}",
+        format!("ow alias set <alias> --db <url> --user {}", username).cyan()
+    );
+
+    Ok(())
+}
+
+async fn cmd_delete(pool: &PgPool, username: &str) -> Result<(), UsersError> {
+    let result = sqlx::query("DELETE FROM users WHERE username = $1")
+        .bind(username)
+        .execute(pool)
+        .await?;
+
+    if result.rows_affected() == 0 {
+        return Err(UsersError::UserNotFound(username.to_string()));
+    }
+
+    println!(
+        "{} User '{}' deleted.",
+        "Deleted".red().bold(),
+        username.bold()
+    );
+
+    Ok(())
+}

src/commands/users.rs

@@ -16,6 +16,7 @@ use commands::env::EnvCommand;
 use commands::kv::KvCommand;
 use commands::migrate::MigrateCommand;
 use commands::storage::StorageCommand;
+use commands::users::UsersCommand;
 use commands::workers::WorkersCommand;
 use config::{AliasConfig, Config, PlatformStorageConfig};
 
@@ -26,6 +27,12 @@ const EXAMPLES: &str = color_print::cstr!(
   ow workers create my-api              <dim>Create a new worker</dim>
   ow workers deploy my-api worker.ts    <dim>Deploy code to worker</dim>
 
+  <dim># Self-hosting (database setup)</dim>
+  ow alias set local --db postgres://... <dim>Configure DB connection</dim>
+  ow local migrate run                  <dim>Run migrations</dim>
+  ow local users create admin           <dim>Create first user (bootstrap)</dim>
+  ow alias set local --db postgres://... --user admin  <dim>Set user context</dim>
+
   <dim># Environment and bindings</dim>
   ow env create prod                    <dim>Create an environment</dim>
   ow kv create cache                    <dim>Create a KV namespace</dim>
@@ -90,6 +97,20 @@ enum Commands {
         command: MigrateCommand,
     },
 
+    /// Manage users (requires db alias, no user context needed for create)
+    #[command(
+        visible_alias = "u",
+        alias = "user",
+        after_help = "Examples:\n  \
+        ow local users list                    List all users\n  \
+        ow local users create admin            Create user (bootstrap mode)\n  \
+        ow local users get admin               Show user details"
+    )]
+    Users {
+        #[command(subcommand)]
+        command: UsersCommand,
+    },
+
     /// Create, deploy, and manage workers
     #[command(
         visible_alias = "w",
@@ -218,19 +239,22 @@ fn extract_alias_from_args() -> (Option<String>, Vec<String>) {
         "alias",
         "login",
         "migrate",
+        "users",
         "workers",
         "env",
         "storage",
         "kv",
         "databases",
         "setup-storage",
         // Short aliases
+        "u",
         "w",
         "e",
         "s",
         "k",
         "d",
         // Singular/plural variants (for flexibility)
+        "user",
         "worker",
         "envs",
         "environment",
@@ -514,6 +538,7 @@ async fn main() {
             commands::login::run(&alias_name).map_err(|e| e.to_string())
         })(),
         Commands::Migrate { command } => command.run(alias).await.map_err(|e| e.to_string()),
+        Commands::Users { command } => command.run(alias).await.map_err(|e| e.to_string()),
         Commands::Workers { command } => run_workers_command(alias, command).await,
         Commands::Env { command } => run_env_command(alias, command).await,
         Commands::Storage { command } => run_storage_command(alias, command).await,