Add db baseline command and mc-style alias syntax

- ow <alias> db migrate instead of ow --alias <alias> db migrate
- db baseline marks all migrations as applied (for existing DBs)

Author: max-lt

README.md

@@ -49,10 +49,13 @@ Requires a `db` type alias.
 
 ```bash
 # Run pending migrations
-ow --alias infra db migrate
+ow infra db migrate
 
 # Check migration status
-ow --alias infra db status
+ow infra db status
+
+# Baseline existing database (mark all migrations as applied without running them)
+ow infra db baseline
 ```
 
 ### Using Aliases
@@ -61,8 +64,9 @@ ow --alias infra db status
 # Use default alias
 ow db status
 
-# Use specific alias
-ow --alias infra db migrate
+# Use specific alias (mc-style, alias as first argument)
+ow infra db migrate
+ow prod db status
 ```
 
 ## Config File Format

src/commands/db.rs

@@ -32,6 +32,9 @@ pub enum DbCommand {
 
     /// Show migration status
     Status,
+
+    /// Mark all migrations as applied without running them (for existing databases)
+    Baseline,
 }
 
 impl DbCommand {
@@ -42,6 +45,7 @@ impl DbCommand {
         match self {
             Self::Migrate => cmd_migrate(&pool).await,
             Self::Status => cmd_status(&pool).await,
+            Self::Baseline => cmd_baseline(&pool).await,
         }
     }
 }
@@ -137,3 +141,63 @@ async fn cmd_status(pool: &PgPool) -> Result<(), DbError> {
 
     Ok(())
 }
+
+async fn cmd_baseline(pool: &PgPool) -> Result<(), DbError> {
+    // Create _sqlx_migrations table if it doesn't exist
+    sqlx::query(
+        r#"
+        CREATE TABLE IF NOT EXISTS _sqlx_migrations (
+            version BIGINT PRIMARY KEY,
+            description TEXT NOT NULL,
+            installed_on TIMESTAMPTZ NOT NULL DEFAULT now(),
+            success BOOLEAN NOT NULL,
+            checksum BYTEA NOT NULL,
+            execution_time BIGINT NOT NULL
+        )
+        "#,
+    )
+    .execute(pool)
+    .await?;
+
+    // Check if already baselined
+    let count: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM _sqlx_migrations")
+        .fetch_one(pool)
+        .await?;
+
+    if count > 0 {
+        println!(
+            "{} Database already has {} migration(s) recorded.",
+            "Warning:".yellow().bold(),
+            count
+        );
+        println!("Use '{}' to check status.", "ow db status".cyan());
+        return Ok(());
+    }
+
+    println!("Marking all migrations as applied...\n");
+
+    for migration in MIGRATOR.iter() {
+        sqlx::query(
+            r#"
+            INSERT INTO _sqlx_migrations (version, description, success, checksum, execution_time)
+            VALUES ($1, $2, true, $3, 0)
+            "#,
+        )
+        .bind(migration.version)
+        .bind(&*migration.description)
+        .bind(&migration.checksum[..])
+        .execute(pool)
+        .await?;
+
+        println!("  {} {}", "Baseline".blue(), migration.description);
+    }
+
+    // Drop old _migrations table if it exists
+    sqlx::query("DROP TABLE IF EXISTS _migrations")
+        .execute(pool)
+        .await?;
+
+    println!("\n{}", "Baseline complete.".green().bold());
+
+    Ok(())
+}

src/main.rs

@@ -6,15 +6,12 @@ use colored::Colorize;
 
 use commands::alias::AliasCommand;
 use commands::db::DbCommand;
+use config::Config;
 
 #[derive(Parser)]
 #[command(name = "ow")]
 #[command(author, version, about = "OpenWorkers CLI", long_about = None)]
 struct Cli {
-    /// Use a specific alias
-    #[arg(long, global = true)]
-    alias: Option<String>,
-
     #[command(subcommand)]
     command: Commands,
 }
@@ -34,13 +31,57 @@ enum Commands {
     },
 }
 
+/// Extract alias from args if first arg matches a known alias.
+/// Returns (alias, filtered_args) where filtered_args has the alias removed.
+fn extract_alias_from_args() -> (Option<String>, Vec<String>) {
+    let args: Vec<String> = std::env::args().collect();
+
+    // Need at least: program name + potential alias + command
+    if args.len() < 2 {
+        return (None, args);
+    }
+
+    let potential_alias = &args[1];
+
+    // Skip if it looks like a flag or is a known command
+    if potential_alias.starts_with('-') {
+        return (None, args);
+    }
+
+    let known_commands = ["alias", "db", "help", "--help", "-h", "--version", "-V"];
+
+    if known_commands.contains(&potential_alias.as_str()) {
+        return (None, args);
+    }
+
+    // Check if it's a known alias
+    if let Ok(config) = Config::load() {
+        if config.get_alias(potential_alias).is_some() {
+            // Remove the alias from args
+            let mut filtered: Vec<String> = Vec::with_capacity(args.len() - 1);
+            filtered.push(args[0].clone());
+            filtered.extend(args[2..].iter().cloned());
+            return (Some(potential_alias.clone()), filtered);
+        }
+    }
+
+    (None, args)
+}
+
 #[tokio::main]
 async fn main() {
-    let cli = Cli::parse();
+    let (alias, args) = extract_alias_from_args();
+
+    let cli = match Cli::try_parse_from(&args) {
+        Ok(cli) => cli,
+        Err(e) => {
+            e.exit();
+        }
+    };
 
     let result = match cli.command {
         Commands::Alias { command } => command.run().map_err(|e| e.to_string()),
-        Commands::Db { command } => command.run(cli.alias).await.map_err(|e| e.to_string()),
+        Commands::Db { command } => command.run(alias).await.map_err(|e| e.to_string()),
     };
 
     if let Err(e) = result {