Merge pull request #53 from mdabir1203/codex/build-minimalist-landing-page-with-stripe-integration

[shadowmap] feat: add marketing landing page with Stripe checkout

Author: mdabir1203

README.md

@@ -40,6 +40,32 @@ cargo fmt --all
 cargo clippy --workspace --all-targets -- -D warnings
 ```
 
+### Landing page & billing checkout
+
+ShadowMap now ships with a minimalist marketing landing page, localized pricing, and optional Stripe Checkout integration.
+
+1. Export your Stripe credentials and price IDs (test or live):
+   ```bash
+   export STRIPE_PUBLISHABLE_KEY=pk_test_...
+   export STRIPE_SECRET_KEY=sk_test_...
+   export STRIPE_PRICE_STARTER_USD=price_123
+   export STRIPE_PRICE_STARTER_EUR=price_456
+   export STRIPE_PRICE_GROWTH_USD=price_789
+   export STRIPE_PRICE_GROWTH_EUR=price_abc
+   export STRIPE_PRICE_ENTERPRISE_USD=price_def
+   export STRIPE_PRICE_ENTERPRISE_EUR=price_ghi
+   # Optional overrides for post-checkout navigation
+   export STRIPE_SUCCESS_URL=https://shadowmap.io/app?checkout=success
+   export STRIPE_CANCEL_URL=https://shadowmap.io/pricing
+   ```
+
+2. Launch the server:
+   ```bash
+   cargo run --bin shadowmap-server
+   ```
+
+3. Visit `http://localhost:8080/` for the public landing page and `http://localhost:8080/app` for the authenticated recon dashboard.
+
 ### Supply Chain Security
 
 ShadowMap includes a lightweight workflow for generating a Software Bill of Materials (SBOM) and scanning it for known vulnerab

src/server.rs

@@ -4,17 +4,18 @@ use axum::{
     extract::{Form, Path, State},
     http::{header, StatusCode},
     response::{Html, IntoResponse, Response},
-    routing::get,
-    Router,
+    routing::{get, post},
+    Json, Router,
 };
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 use shadowmap::{run, Args};
 use tracing::{error, info};
 
 mod web;
 
 use web::{
-    render_index_page, render_job_row, render_job_rows, AppState, JobConfig, JobId, JobStatus,
+    render_index_page, render_job_row, render_job_rows, render_landing_page, AppState, JobConfig,
+    JobId, JobStatus, LandingPageContext, PricingPlan,
 };
 
 #[derive(Debug, Deserialize)]
@@ -46,10 +47,12 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
 
     let state = AppState::new();
     let app = Router::new()
-        .route("/", get(index))
+        .route("/", get(landing))
+        .route("/app", get(index))
         .route("/jobs", get(list_jobs).post(create_job))
         .route("/jobs/:id", get(job_row))
         .route("/jobs/:id/report", get(job_report))
+        .route("/create-checkout-session", post(create_checkout_session))
         .with_state(state);
 
     let addr: SocketAddr = "0.0.0.0:8080".parse()?;
@@ -68,6 +71,11 @@ async fn shutdown_signal() {
     info!("shutdown signal received");
 }
 
+async fn landing() -> Html<String> {
+    let context = build_landing_page_context();
+    Html(render_landing_page(&context))
+}
+
 async fn index(State(state): State<AppState>) -> Html<String> {
     let jobs = state.list_jobs().await;
     Html(render_index_page(&jobs))
@@ -155,3 +163,196 @@ async fn run_job(state: AppState, job_id: JobId, domain: String, config: JobConf
         }
     }
 }
+
+#[derive(Debug, Deserialize)]
+struct CheckoutRequest {
+    plan_id: String,
+    region: String,
+    email: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+struct CheckoutResponse {
+    session_id: String,
+}
+
+#[derive(Debug, Deserialize)]
+struct StripeSession {
+    id: String,
+}
+
+async fn create_checkout_session(
+    Json(payload): Json<CheckoutRequest>,
+) -> Result<Json<CheckoutResponse>, (StatusCode, String)> {
+    let plan = payload.plan_id.trim().to_lowercase();
+    let region = payload.region.trim().to_lowercase();
+    let Some(env_key) = stripe_price_env_key(&plan, &region) else {
+        return Err((
+            StatusCode::BAD_REQUEST,
+            "Unknown plan or region selected".to_string(),
+        ));
+    };
+
+    let price_id = std::env::var(env_key).map_err(|_| {
+        (
+            StatusCode::BAD_REQUEST,
+            "Checkout is not available for the selected plan in this region yet.".to_string(),
+        )
+    })?;
+
+    let secret_key = std::env::var("STRIPE_SECRET_KEY").map_err(|_| {
+        (
+            StatusCode::SERVICE_UNAVAILABLE,
+            "Stripe payments are not configured.".to_string(),
+        )
+    })?;
+
+    let success_url = std::env::var("STRIPE_SUCCESS_URL")
+        .unwrap_or_else(|_| "https://shadowmap.io/app?checkout=success".to_string());
+    let cancel_url = std::env::var("STRIPE_CANCEL_URL")
+        .unwrap_or_else(|_| "https://shadowmap.io/pricing".to_string());
+
+    let mut form_body = vec![
+        ("mode".to_string(), "subscription".to_string()),
+        ("line_items[0][price]".to_string(), price_id),
+        ("line_items[0][quantity]".to_string(), "1".to_string()),
+        ("success_url".to_string(), success_url),
+        ("cancel_url".to_string(), cancel_url),
+        ("allow_promotion_codes".to_string(), "true".to_string()),
+    ];
+
+    if let Some(email) = payload.email.and_then(|value| {
+        let trimmed = value.trim();
+        if trimmed.is_empty() {
+            None
+        } else {
+            Some(trimmed.to_string())
+        }
+    }) {
+        form_body.push(("customer_email".to_string(), email));
+    }
+
+    let client = reqwest::Client::new();
+    let response = client
+        .post("https://api.stripe.com/v1/checkout/sessions")
+        .bearer_auth(secret_key)
+        .form(&form_body)
+        .send()
+        .await
+        .map_err(|err| {
+            error!(?err, "failed to talk to stripe");
+            (
+                StatusCode::BAD_GATEWAY,
+                "Unable to reach Stripe right now. Please try again.".to_string(),
+            )
+        })?;
+
+    let status = response.status();
+    let body = response.text().await.map_err(|err| {
+        error!(?err, "failed to read stripe response");
+        (
+            StatusCode::BAD_GATEWAY,
+            "Received an unexpected response from Stripe.".to_string(),
+        )
+    })?;
+
+    if !status.is_success() {
+        error!(?status, body = %body, "stripe returned an error");
+        return Err((
+            StatusCode::BAD_GATEWAY,
+            "Stripe rejected the checkout session. Contact support if this persists.".to_string(),
+        ));
+    }
+
+    let session: StripeSession = serde_json::from_str(&body).map_err(|err| {
+        error!(?err, body = %body, "failed to parse stripe session");
+        (
+            StatusCode::BAD_GATEWAY,
+            "Unexpected response from payment processor.".to_string(),
+        )
+    })?;
+
+    Ok(Json(CheckoutResponse {
+        session_id: session.id,
+    }))
+}
+
+fn build_landing_page_context() -> LandingPageContext {
+    let publishable_key = std::env::var("STRIPE_PUBLISHABLE_KEY").ok();
+    let plans = vec![
+        PricingPlan {
+            id: "starter",
+            name: "Starter",
+            summary: "Launch automation-grade recon for boutique agencies and red teams.",
+            ideal_for: "Solo operators",
+            highlight: false,
+            usd_cents: 7900,
+            eur_cents: 7500,
+            features: &[
+                "Unlimited on-demand reconnaissance jobs",
+                "Live subdomain, DNS, and takeover detection",
+                "Automated PDF & JSON reporting exports",
+                "Email support with 1-business-day SLA",
+            ],
+            checkout_ready_us: stripe_price_configured("starter", "us"),
+            checkout_ready_eu: stripe_price_configured("starter", "eu"),
+        },
+        PricingPlan {
+            id: "growth",
+            name: "Growth",
+            summary: "Scale your practice with team workspaces, automations, and real-time monitoring.",
+            ideal_for: "Agencies & MSSPs",
+            highlight: true,
+            usd_cents: 15900,
+            eur_cents: 14900,
+            features: &[
+                "Everything in Starter plus scheduled monitoring",
+                "Team workspaces with role-based access control",
+                "Slack and webhook alerting for high-risk findings",
+                "Dedicated success engineer and quarterly playbooks",
+            ],
+            checkout_ready_us: stripe_price_configured("growth", "us"),
+            checkout_ready_eu: stripe_price_configured("growth", "eu"),
+        },
+        PricingPlan {
+            id: "enterprise",
+            name: "Enterprise",
+            summary: "For global security organizations that need private deployments and custom workflows.",
+            ideal_for: "Global teams",
+            highlight: false,
+            usd_cents: 34900,
+            eur_cents: 32900,
+            features: &[
+                "Private cloud or on-premise deployment options",
+                "Custom modules and API surface for internal tooling",
+                "Advanced compliance reporting & SOC2 documentation",
+                "24/7 incident response with named TAM",
+            ],
+            checkout_ready_us: stripe_price_configured("enterprise", "us"),
+            checkout_ready_eu: stripe_price_configured("enterprise", "eu"),
+        },
+    ];
+
+    LandingPageContext {
+        publishable_key,
+        plans,
+    }
+}
+
+fn stripe_price_configured(plan: &str, region: &str) -> bool {
+    stripe_price_env_key(plan, region)
+        .and_then(|key| std::env::var(key).ok())
+        .is_some()
+}
+
+fn stripe_price_env_key(plan: &str, region: &str) -> Option<&'static str> {
+    match (plan, region) {
+        ("starter", "us") => Some("STRIPE_PRICE_STARTER_USD"),
+        ("starter", "eu") => Some("STRIPE_PRICE_STARTER_EUR"),
+        ("growth", "us") => Some("STRIPE_PRICE_GROWTH_USD"),
+        ("growth", "eu") => Some("STRIPE_PRICE_GROWTH_EUR"),
+        ("enterprise", "us") => Some("STRIPE_PRICE_ENTERPRISE_USD"),
+        ("enterprise", "eu") => Some("STRIPE_PRICE_ENTERPRISE_EUR"),
+        _ => None,
+    }
+}

src/web/mod.rs

@@ -2,4 +2,7 @@ pub mod state;
 pub mod views;
 
 pub use state::{AppState, JobConfig, JobId, JobStatus};
-pub use views::{render_index_page, render_job_row, render_job_rows};
+pub use views::{
+    render_index_page, render_job_row, render_job_rows, render_landing_page, LandingPageContext,
+    PricingPlan,
+};