Enable closed workflow

Author: S1ro1

CONTRIBUTING.md

@@ -154,6 +154,11 @@ popcorn admin create-leaderboard <dir> # Create leaderboard from problem directo
 popcorn admin delete-leaderboard <name>        # Delete a leaderboard
 popcorn admin delete-leaderboard <name> --force # Force delete with submissions
 
+# Invite management
+popcorn admin generate-invites --leaderboards lb1 lb2 --count 5  # Generate invite codes
+popcorn admin list-invites <leaderboard>                          # List invites for a leaderboard
+popcorn admin revoke-invite <code>                                # Revoke an invite code
+
 # Update problems from GitHub
 popcorn admin update-problems
 popcorn admin update-problems --problem-set nvidia --force

docs/helion-hackathon.md

@@ -25,7 +25,10 @@ curl -fsSL https://raw.githubusercontent.com/gpu-mode/popcorn-cli/main/install.s
 # 2. Register
 popcorn register discord
 
-# 3. Setup a project (downloads the submission template for you)
+# 3. Join the challenge with your invite code
+popcorn join <YOUR_INVITE_CODE>
+
+# 4. Setup a project (downloads the submission template for you)
 popcorn setup
 # Select "Helion Kernel Challenge", then pick a problem and GPU
 ```

src/cmd/admin.rs

@@ -39,6 +39,26 @@ pub enum AdminAction {
         #[arg(long)]
         force: bool,
     },
+    /// Generate invite codes for leaderboard(s)
+    GenerateInvites {
+        /// Leaderboard names to grant access to
+        #[arg(long, required = true, num_args = 1..)]
+        leaderboards: Vec<String>,
+
+        /// Number of invite codes to generate (1-10000)
+        #[arg(long, default_value = "1")]
+        count: u32,
+    },
+    /// List invite codes for a leaderboard
+    ListInvites {
+        /// Leaderboard name
+        leaderboard: String,
+    },
+    /// Revoke an invite code
+    RevokeInvite {
+        /// The invite code to revoke
+        code: String,
+    },
     /// Update problems from a GitHub repository (mirrors Discord /admin update-problems)
     UpdateProblems {
         /// Problem set name (e.g., "nvidia", "pmpp_v2"). If not specified, updates all.
@@ -56,6 +76,10 @@ pub enum AdminAction {
         /// Force update even if task definition changed significantly
         #[arg(long)]
         force: bool,
+
+        /// Set leaderboard visibility to closed (requires invite to access)
+        #[arg(long)]
+        closed: bool,
     },
 }
 
@@ -108,27 +132,109 @@ pub async fn handle_admin(action: AdminAction) -> Result<()> {
             println!("Deleted leaderboard '{}'", name);
             println!("{}", serde_json::to_string_pretty(&result)?);
         }
+        AdminAction::GenerateInvites {
+            leaderboards,
+            count,
+        } => {
+            let result = service::admin_generate_invites(&client, &leaderboards, count).await?;
+            let codes = result["codes"].as_array().map(|arr| arr.len()).unwrap_or(0);
+            let lbs = result["leaderboards"]
+                .as_array()
+                .map(|arr| {
+                    arr.iter()
+                        .filter_map(|v| v.as_str())
+                        .collect::<Vec<_>>()
+                        .join(", ")
+                })
+                .unwrap_or_default();
+            println!("Generated {} invite code(s) for: {}", codes, lbs);
+            if let Some(arr) = result["codes"].as_array() {
+                for code in arr {
+                    println!("  {}", code.as_str().unwrap_or("???"));
+                }
+            }
+        }
+        AdminAction::ListInvites { leaderboard } => {
+            let result = service::admin_list_invites(&client, &leaderboard).await?;
+            let invites = result["invites"].as_array();
+            match invites {
+                Some(arr) if arr.is_empty() => {
+                    println!("No invites for '{}'", leaderboard);
+                }
+                Some(arr) => {
+                    let claimed = arr
+                        .iter()
+                        .filter(|i| i["user_id"].as_str().is_some())
+                        .count();
+                    println!(
+                        "Invites for '{}': {} total, {} claimed, {} unclaimed\n",
+                        leaderboard,
+                        arr.len(),
+                        claimed,
+                        arr.len() - claimed,
+                    );
+                    let header = format!(
+                        "{:<26} {:<16} {:<20} {}",
+                        "CODE", "STATUS", "CLAIMED BY", "CREATED"
+                    );
+                    println!("{header}");
+                    println!("{}", "-".repeat(82));
+                    for invite in arr {
+                        let code = invite["code"].as_str().unwrap_or("???");
+                        let user = invite["user_name"]
+                            .as_str()
+                            .or_else(|| invite["user_id"].as_str());
+                        let status = if user.is_some() {
+                            "claimed"
+                        } else {
+                            "unclaimed"
+                        };
+                        let user_display = user.unwrap_or("-");
+                        let created = invite["created_at"].as_str().unwrap_or("-");
+                        println!(
+                            "{:<26} {:<16} {:<20} {}",
+                            code, status, user_display, created,
+                        );
+                    }
+                }
+                None => {
+                    println!("{}", serde_json::to_string_pretty(&result)?);
+                }
+            }
+        }
+        AdminAction::RevokeInvite { code } => {
+            let result = service::admin_revoke_invite(&client, &code).await?;
+            let was_claimed = result["was_claimed"].as_bool().unwrap_or(false);
+            println!(
+                "Revoked invite code '{}' (was {})",
+                code,
+                if was_claimed { "claimed" } else { "unclaimed" }
+            );
+        }
         AdminAction::UpdateProblems {
             problem_set,
             repository,
             branch,
             force,
+            closed,
         } => {
             println!(
-                "Updating problems from {}/tree/{}{}...",
+                "Updating problems from {}/tree/{}{}{}...",
                 repository,
                 branch,
                 problem_set
                     .as_ref()
                     .map(|ps| format!(" (problem set: {})", ps))
-                    .unwrap_or_default()
+                    .unwrap_or_default(),
+                if closed { " (closed)" } else { "" },
             );
             let result = service::admin_update_problems(
                 &client,
                 problem_set.as_deref(),
                 &repository,
                 &branch,
                 force,
+                closed,
             )
             .await?;
 

src/cmd/mod.rs

@@ -10,6 +10,8 @@ mod setup;
 mod submissions;
 mod submit;
 
+use crate::service;
+
 pub use admin::AdminAction;
 
 #[derive(Serialize, Deserialize, Debug, Default)]
@@ -138,6 +140,11 @@ enum Commands {
         #[arg(long)]
         no_tui: bool,
     },
+    /// Join a closed leaderboard using an invite code
+    Join {
+        /// The invite code
+        code: String,
+    },
     /// Admin commands (requires POPCORN_ADMIN_TOKEN env var)
     Admin {
         #[command(subcommand)]
@@ -209,6 +216,29 @@ pub async fn execute(cli: Cli) -> Result<()> {
                 .await
             }
         }
+        Some(Commands::Join { code }) => {
+            let config = load_config()?;
+            let cli_id = config.cli_id.ok_or_else(|| {
+                anyhow!(
+                    "cli_id not found in config file ({}). Please run `popcorn register` first.",
+                    get_config_path()
+                        .map_or_else(|_| "unknown path".to_string(), |p| p.display().to_string())
+                )
+            })?;
+            let client = service::create_client(Some(cli_id))?;
+            let result = service::join_with_invite(&client, &code).await?;
+            let leaderboards = result["leaderboards"]
+                .as_array()
+                .map(|arr| {
+                    arr.iter()
+                        .filter_map(|v| v.as_str())
+                        .collect::<Vec<_>>()
+                        .join(", ")
+                })
+                .unwrap_or_default();
+            println!("Joined leaderboard(s): {}", leaderboards);
+            Ok(())
+        }
         Some(Commands::Admin { action }) => admin::handle_admin(action).await,
         Some(Commands::Submissions { action }) => {
             let config = load_config()?;

src/service/mod.rs

@@ -188,6 +188,7 @@ pub async fn admin_update_problems(
     repository: &str,
     branch: &str,
     force: bool,
+    closed: bool,
 ) -> Result<Value> {
     let base_url =
         env::var("POPCORN_API_URL").map_err(|_| anyhow!("POPCORN_API_URL is not set"))?;
@@ -202,6 +203,10 @@ pub async fn admin_update_problems(
         payload["problem_set"] = serde_json::Value::String(ps.to_string());
     }
 
+    if closed {
+        payload["visibility"] = serde_json::Value::String("closed".to_string());
+    }
+
     let resp = client
         .post(format!("{}/admin/update-problems", base_url))
         .json(&payload)
@@ -212,6 +217,61 @@ pub async fn admin_update_problems(
     handle_admin_response(resp).await
 }
 
+/// Generate invite codes for one or more leaderboards
+pub async fn admin_generate_invites(
+    client: &Client,
+    leaderboards: &[String],
+    count: u32,
+) -> Result<Value> {
+    let base_url =
+        env::var("POPCORN_API_URL").map_err(|_| anyhow!("POPCORN_API_URL is not set"))?;
+
+    let payload = serde_json::json!({
+        "leaderboards": leaderboards,
+        "count": count,
+    });
+
+    let resp = client
+        .post(format!("{}/admin/invites", base_url))
+        .json(&payload)
+        .timeout(Duration::from_secs(30))
+        .send()
+        .await?;
+
+    handle_admin_response(resp).await
+}
+
+/// List invite codes for a leaderboard
+pub async fn admin_list_invites(client: &Client, leaderboard_name: &str) -> Result<Value> {
+    let base_url =
+        env::var("POPCORN_API_URL").map_err(|_| anyhow!("POPCORN_API_URL is not set"))?;
+
+    let resp = client
+        .get(format!(
+            "{}/admin/leaderboards/{}/invites",
+            base_url, leaderboard_name
+        ))
+        .timeout(Duration::from_secs(30))
+        .send()
+        .await?;
+
+    handle_admin_response(resp).await
+}
+
+/// Revoke an invite code
+pub async fn admin_revoke_invite(client: &Client, code: &str) -> Result<Value> {
+    let base_url =
+        env::var("POPCORN_API_URL").map_err(|_| anyhow!("POPCORN_API_URL is not set"))?;
+
+    let resp = client
+        .delete(format!("{}/admin/invites/{}", base_url, code))
+        .timeout(Duration::from_secs(30))
+        .send()
+        .await?;
+
+    handle_admin_response(resp).await
+}
+
 /// Helper to handle admin API responses
 async fn handle_admin_response(resp: reqwest::Response) -> Result<Value> {
     let status = resp.status();
@@ -447,6 +507,38 @@ pub async fn delete_user_submission(client: &Client, submission_id: i64) -> Resu
         .map_err(|e| anyhow!("Failed to parse response: {}", e))
 }
 
+/// Claim an invite code to join closed leaderboard(s)
+pub async fn join_with_invite(client: &Client, code: &str) -> Result<Value> {
+    let base_url =
+        env::var("POPCORN_API_URL").map_err(|_| anyhow!("POPCORN_API_URL is not set"))?;
+
+    let payload = serde_json::json!({ "code": code });
+
+    let resp = client
+        .post(format!("{}/user/join", base_url))
+        .json(&payload)
+        .timeout(Duration::from_secs(30))
+        .send()
+        .await?;
+
+    let status = resp.status();
+    if !status.is_success() {
+        let error_text = resp.text().await?;
+        let detail = serde_json::from_str::<Value>(&error_text)
+            .ok()
+            .and_then(|v| v.get("detail").and_then(|d| d.as_str()).map(str::to_string));
+        return Err(anyhow!(
+            "Server returned status {}: {}",
+            status,
+            detail.unwrap_or(error_text)
+        ));
+    }
+
+    resp.json()
+        .await
+        .map_err(|e| anyhow!("Failed to parse response: {}", e))
+}
+
 pub async fn submit_solution<P: AsRef<Path>>(
     client: &Client,
     filepath: P,