vigile-scan 0.2.5 → 2.1.0

package/dist/index.js

@@ -31,7 +31,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "vigile-scan",
-      version: "0.2.5",
+      version: "2.1.0",
       description: "Security scanner for AI agent tools \u2014 detect tool poisoning, permission abuse, and supply chain attacks in MCP servers and agent skills",
       main: "dist/index.js",
       bin: {
@@ -71,15 +71,15 @@ var require_package = __commonJS({
         "cursor",
         "copilot"
       ],
-      author: "Vigile AI Security",
+      author: "Vigile AI",
       license: "Apache-2.0",
       homepage: "https://vigile.dev",
       repository: {
         type: "git",
-        url: "git+https://github.com/Vigile-ai/vigile-cli.git"
+        url: "git+https://github.com/Vigile-ai/vigile-scan.git"
       },
       bugs: {
-        url: "https://github.com/Vigile-ai/vigile-cli/issues"
+        url: "https://github.com/Vigile-ai/vigile-scan/issues"
       },
       publishConfig: {
         access: "public"
@@ -2435,8 +2435,8 @@ function printSentinelUpgrade() {
   console.log(import_chalk.default.yellow(`  \u26A1 Sentinel is a Pro feature. Upgrade to unlock runtime monitoring:`));
   console.log(import_chalk.default.cyan(`     https://vigile.dev/pricing`));
   console.log("");
-  console.log(import_chalk.default.gray(`  Pro ($9.99/mo)     \u2014 5-min sessions, 3 servers, behavioral detection`));
-  console.log(import_chalk.default.gray(`  Pro+ ($29.99/mo)   \u2014 30-min sessions, 10 servers, DNS tunneling & C2 detection`));
+  console.log(import_chalk.default.gray(`  Pro ($29/mo)        \u2014 5-min sessions, 3 servers, behavioral detection`));
+  console.log(import_chalk.default.gray(`  Pro+ ($99/mo)      \u2014 30-min sessions, 10 servers, DNS tunneling & C2 detection`));
   console.log("");
 }
 function printAuthStatus(info) {
@@ -2685,6 +2685,2335 @@ async function getAuthenticatedClient() {
   return new VigileApiClient(apiUrl, token);
 }
 
+// src/scanner/baas/secret-patterns.ts
+function mask(secret) {
+  if (secret.length <= 8) return "***";
+  return `${secret.slice(0, 4)}***${secret.slice(-4)}`;
+}
+var SECRET_PATTERNS = [
+  // ── AI / LLM Providers ──
+  {
+    id: "SP-001",
+    name: "OpenAI API Key",
+    provider: "openai",
+    severity: "critical",
+    pattern: /sk-[A-Za-z0-9]{48}/,
+    description: "OpenAI API key grants full access to GPT-4, Whisper, DALL-E, and all models. Exposed keys result in immediate billing charges.",
+    recommendation: "Rotate at platform.openai.com/api-keys immediately. Move all AI calls to a server-side proxy."
+  },
+  {
+    id: "SP-002",
+    name: "OpenAI Project API Key",
+    provider: "openai",
+    severity: "critical",
+    pattern: /sk-proj-[A-Za-z0-9_-]{80,120}/,
+    description: "OpenAI project-scoped API key. Exposed keys grant API access within the project scope.",
+    recommendation: "Rotate at platform.openai.com/api-keys. Never include in client-side JavaScript."
+  },
+  {
+    id: "SP-003",
+    name: "OpenAI Organization ID",
+    provider: "openai",
+    severity: "medium",
+    pattern: /org-[A-Za-z0-9]{24}/,
+    description: "OpenAI organization identifier. Exposure can leak organizational structure.",
+    recommendation: "Treat as sensitive. Pass server-side only."
+  },
+  {
+    id: "SP-004",
+    name: "Anthropic API Key",
+    provider: "anthropic",
+    severity: "critical",
+    pattern: /sk-ant-api\d{2}-[A-Za-z0-9_-]{93,100}/,
+    description: "Anthropic Claude API key. Grants access to Claude Sonnet, Opus, and Haiku. Full billing exposure.",
+    recommendation: "Rotate at console.anthropic.com. All Claude API calls must be server-side."
+  },
+  {
+    id: "SP-005",
+    name: "Anthropic Session Token",
+    provider: "anthropic",
+    severity: "critical",
+    pattern: /sk-ant-oau\d{2}-[A-Za-z0-9_-]{80,}/,
+    description: "Anthropic OAuth session token. Short-lived but grants full account access if intercepted.",
+    recommendation: "These should never appear in bundles. Remove immediately and revoke session."
+  },
+  {
+    id: "SP-006",
+    name: "HuggingFace User Token",
+    provider: "huggingface",
+    severity: "high",
+    pattern: /hf_[A-Za-z0-9]{34,40}/,
+    description: "HuggingFace API token. Grants access to models, datasets, and inference API.",
+    recommendation: "Rotate at huggingface.co/settings/tokens. Use read-only tokens for public model access."
+  },
+  {
+    id: "SP-007",
+    name: "HuggingFace Org Token",
+    provider: "huggingface",
+    severity: "high",
+    pattern: /api_org_[A-Za-z0-9]{34,40}/,
+    description: "HuggingFace organization API token with org-level privileges.",
+    recommendation: "Rotate at huggingface.co/settings/tokens. Grant minimum required permissions."
+  },
+  {
+    id: "SP-008",
+    name: "Replicate API Token",
+    provider: "replicate",
+    severity: "high",
+    pattern: /r8_[A-Za-z0-9]{35,40}/,
+    description: "Replicate API token. Grants access to run ML models with per-second billing.",
+    recommendation: "Rotate at replicate.com/account/api-tokens. All inference must be server-side."
+  },
+  {
+    id: "SP-009",
+    name: "Cohere API Key",
+    provider: "cohere",
+    severity: "high",
+    pattern: /(?:co-|COHERE_API_KEY['":\s=]+)([A-Za-z0-9]{40,50})/,
+    description: "Cohere API key for language model inference and embeddings.",
+    recommendation: "Rotate at dashboard.cohere.com/api-keys."
+  },
+  {
+    id: "SP-010",
+    name: "Groq API Key",
+    provider: "groq",
+    severity: "high",
+    pattern: /gsk_[A-Za-z0-9]{48,60}/,
+    description: "Groq API key. Grants ultra-fast LLM inference on Llama, Mixtral, Gemma models.",
+    recommendation: "Rotate at console.groq.com/keys. Never ship in client bundles."
+  },
+  {
+    id: "SP-011",
+    name: "Together AI API Key",
+    provider: "together-ai",
+    severity: "high",
+    pattern: /(?:TOGETHER_API_KEY|together_api_key)['":\s=]+([A-Za-z0-9]{64})/i,
+    description: "Together AI API key for open-source LLM inference.",
+    recommendation: "Rotate at api.together.xyz/settings/api-keys."
+  },
+  {
+    id: "SP-012",
+    name: "Mistral AI API Key",
+    provider: "mistral",
+    severity: "high",
+    pattern: /(?:MISTRAL_API_KEY|mistral_api_key)['":\s=]+([A-Za-z0-9]{32,40})/i,
+    description: "Mistral AI API key for Mistral-7B, Mixtral, and Codestral models.",
+    recommendation: "Rotate at console.mistral.ai/api-keys."
+  },
+  {
+    id: "SP-013",
+    name: "Perplexity API Key",
+    provider: "perplexity",
+    severity: "high",
+    pattern: /pplx-[A-Za-z0-9]{48,60}/,
+    description: "Perplexity AI API key for search-augmented language model access.",
+    recommendation: "Rotate at perplexity.ai/settings/api."
+  },
+  {
+    id: "SP-014",
+    name: "Cerebras API Key",
+    provider: "cerebras",
+    severity: "high",
+    pattern: /csk-[A-Za-z0-9]{40,60}/,
+    description: "Cerebras API key for ultra-fast inference on Llama models.",
+    recommendation: "Rotate at cloud.cerebras.ai. All inference must be server-side."
+  },
+  {
+    id: "SP-015",
+    name: "OpenRouter API Key",
+    provider: "openrouter",
+    severity: "high",
+    pattern: /sk-or-[A-Za-z0-9]{40,60}/,
+    description: "OpenRouter API key providing access to 100+ AI models through a unified API.",
+    recommendation: "Rotate at openrouter.ai/keys."
+  },
+  {
+    id: "SP-016",
+    name: "ElevenLabs API Key",
+    provider: "elevenlabs",
+    severity: "high",
+    pattern: /(?:ELEVENLABS_API_KEY|xi-api-key)['":\s=]+([A-Za-z0-9_-]{32,50})/i,
+    description: "ElevenLabs voice synthesis API key. Grants text-to-speech and voice cloning access.",
+    recommendation: "Rotate at elevenlabs.io/profile/api-key."
+  },
+  {
+    id: "SP-017",
+    name: "AssemblyAI API Key",
+    provider: "assemblyai",
+    severity: "high",
+    pattern: /(?:ASSEMBLYAI_API_KEY)['":\s=]+([a-f0-9]{40,50})/i,
+    description: "AssemblyAI transcription API key. Grants access to speech-to-text and audio intelligence.",
+    recommendation: "Rotate at www.assemblyai.com/app/account."
+  },
+  {
+    id: "SP-018",
+    name: "Deepgram API Key",
+    provider: "deepgram",
+    severity: "high",
+    pattern: /(?:DEEPGRAM_API_KEY)['":\s=]+([a-f0-9]{40,50})/i,
+    description: "Deepgram speech recognition API key.",
+    recommendation: "Rotate at console.deepgram.com/project/api-key."
+  },
+  {
+    id: "SP-019",
+    name: "Stability AI API Key",
+    provider: "stability-ai",
+    severity: "high",
+    pattern: /sk-[A-Za-z0-9]{32,50}(?=['"}\s])/,
+    description: "Stability AI key for image generation (Stable Diffusion). Overlaps with sk- prefix \u2014 validate by context.",
+    recommendation: "Rotate at platform.stability.ai/account/keys."
+  },
+  {
+    id: "SP-020",
+    name: "LangSmith API Key",
+    provider: "langsmith",
+    severity: "medium",
+    pattern: /ls__[A-Za-z0-9_-]{32,50}/,
+    description: "LangSmith API key for LLM observability and tracing.",
+    recommendation: "Rotate at smith.langchain.com/settings."
+  },
+  {
+    id: "SP-021",
+    name: "Weights & Biases API Key",
+    provider: "wandb",
+    severity: "medium",
+    pattern: /(?:WANDB_API_KEY)['":\s=]+([a-f0-9]{40})/i,
+    description: "Weights & Biases ML experiment tracking API key.",
+    recommendation: "Rotate at wandb.ai/authorize."
+  },
+  {
+    id: "SP-022",
+    name: "Helicone API Key",
+    provider: "helicone",
+    severity: "medium",
+    pattern: /sk-helicone-[A-Za-z0-9_-]{30,60}/,
+    description: "Helicone LLM observability API key for caching and monitoring AI calls.",
+    recommendation: "Rotate at helicone.ai/settings."
+  },
+  {
+    id: "SP-023",
+    name: "E2B API Key",
+    provider: "e2b",
+    severity: "high",
+    pattern: /e2b_[A-Za-z0-9_-]{30,50}/,
+    description: "E2B sandbox API key. Grants ability to spin up code execution sandboxes \u2014 billing risk.",
+    recommendation: "Rotate at e2b.dev/dashboard."
+  },
+  {
+    id: "SP-024",
+    name: "Tavily Search API Key",
+    provider: "tavily",
+    severity: "medium",
+    pattern: /tvly-[A-Za-z0-9_-]{30,50}/,
+    description: "Tavily AI search API key.",
+    recommendation: "Rotate at app.tavily.com."
+  },
+  {
+    id: "SP-025",
+    name: "Firecrawl API Key",
+    provider: "firecrawl",
+    severity: "medium",
+    pattern: /fc-[A-Za-z0-9]{32,50}/,
+    description: "Firecrawl web scraping API key.",
+    recommendation: "Rotate at firecrawl.dev/account."
+  },
+  {
+    id: "SP-026",
+    name: "Jina AI API Key",
+    provider: "jina",
+    severity: "medium",
+    pattern: /jina_[A-Za-z0-9_-]{50,80}/,
+    description: "Jina AI API key for embeddings and search.",
+    recommendation: "Rotate at jina.ai/dashboard."
+  },
+  {
+    id: "SP-027",
+    name: "Apify API Token",
+    provider: "apify",
+    severity: "medium",
+    pattern: /apify_api_[A-Za-z0-9]{40,60}/,
+    description: "Apify web scraping platform API token.",
+    recommendation: "Rotate at console.apify.com/account/integrations."
+  },
+  // ── Cloud Providers ──
+  {
+    id: "SP-028",
+    name: "AWS Access Key ID",
+    provider: "aws",
+    severity: "critical",
+    pattern: /AKIA[A-Z0-9]{16}/,
+    description: "AWS IAM Access Key ID. Pair this with a secret key to authenticate against any AWS service.",
+    recommendation: "Rotate immediately in AWS IAM console. Enable MFA. Use instance profiles instead of long-lived keys."
+  },
+  {
+    id: "SP-029",
+    name: "AWS Secret Access Key",
+    provider: "aws",
+    severity: "critical",
+    pattern: /(?:aws[_-]?secret[_-]?(?:access[_-]?)?key|AWS_SECRET(?:_ACCESS_KEY)?)['":\s=]+([A-Za-z0-9/+=]{40})/i,
+    description: "AWS IAM Secret Access Key. Combined with key ID, provides full AWS service access.",
+    recommendation: "Rotate immediately. Audit CloudTrail for unauthorized usage. Use IAM roles instead."
+  },
+  {
+    id: "SP-030",
+    name: "AWS Session Token",
+    provider: "aws",
+    severity: "high",
+    pattern: /(?:AWS_SESSION_TOKEN|aws_session_token)['":\s=]+([A-Za-z0-9/+=]{200,600})/i,
+    description: "Temporary AWS STS session token. Short-lived but grants API access until expiry.",
+    recommendation: "These expire automatically but should not be in client code."
+  },
+  {
+    id: "SP-031",
+    name: "Google Cloud API Key",
+    provider: "google-cloud",
+    severity: "critical",
+    pattern: /AIza[0-9A-Za-z\-_]{35}/,
+    description: "Google Cloud / Firebase API key. Grants access to Google Maps, Firebase, YouTube, and other Google APIs depending on restrictions.",
+    recommendation: "Add API key restrictions in Google Cloud Console. Rotate at console.cloud.google.com/apis/credentials."
+  },
+  {
+    id: "SP-032",
+    name: "Google Service Account Key",
+    provider: "google-cloud",
+    severity: "critical",
+    pattern: /"private_key"\s*:\s*"-----BEGIN RSA PRIVATE KEY/,
+    description: "Google Cloud service account private key embedded in source. Grants IAM service account impersonation.",
+    recommendation: "Revoke the service account key immediately. Use Workload Identity or ADC instead of key files."
+  },
+  {
+    id: "SP-033",
+    name: "Google OAuth Client Secret",
+    provider: "google-cloud",
+    severity: "high",
+    pattern: /GOCSPX-[A-Za-z0-9_-]{28}/,
+    description: "Google OAuth 2.0 client secret. Enables impersonation of your OAuth application.",
+    recommendation: "Rotate at console.cloud.google.com/apis/credentials. Keep client secrets server-side only."
+  },
+  {
+    id: "SP-034",
+    name: "Firebase Web API Key",
+    provider: "firebase",
+    severity: "medium",
+    pattern: /(?:NEXT_PUBLIC_FIREBASE_API_KEY|VITE_FIREBASE_API_KEY|firebase(?:Config)?\.apiKey)['":\s=]+["']?(AIza[0-9A-Za-z\-_]{35})/i,
+    description: "Firebase Web API Key in environment variable. The key itself is semi-public but should be paired with proper security rules.",
+    recommendation: "Restrict key usage in Firebase Console. Ensure Firestore and Storage rules are not open."
+  },
+  {
+    id: "SP-035",
+    name: "Firebase Service Account",
+    provider: "firebase",
+    severity: "critical",
+    pattern: /(?:FIREBASE_SERVICE_ACCOUNT|firebase[_-]admin[_-]sdk)['":\s=]+/i,
+    description: "Firebase Admin SDK service account credentials. Grants admin-level access bypassing all security rules.",
+    recommendation: "Never include Firebase Admin credentials in client bundles. Use client SDK on frontend, Admin SDK on backend only."
+  },
+  {
+    id: "SP-036",
+    name: "Supabase Service Role Key",
+    provider: "supabase",
+    severity: "critical",
+    pattern: /(?:SUPABASE_SERVICE_ROLE_KEY|SUPABASE_SERVICE_KEY|supabase[_-]service[_-]role)['":\s=]+["']?(eyJ[A-Za-z0-9_-]+\.eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+)/i,
+    description: "Supabase service role key. Bypasses ALL Row Level Security policies \u2014 full database admin access.",
+    recommendation: "Immediately rotate in Supabase dashboard > Project Settings > API. This key MUST NEVER be in client code."
+  },
+  {
+    id: "SP-037",
+    name: "Supabase Anon Key (Public)",
+    provider: "supabase",
+    severity: "low",
+    pattern: /(?:NEXT_PUBLIC_SUPABASE_ANON_KEY|VITE_SUPABASE_ANON_KEY|supabase[_-]anon[_-]key)['":\s=]+["']?(eyJ[A-Za-z0-9_-]+\.eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+)/i,
+    description: "Supabase anon/public key. This is designed to be public, but without proper RLS policies, it can expose your data.",
+    recommendation: "Safe to be public ONLY if RLS policies are correctly configured on all tables."
+  },
+  {
+    id: "SP-038",
+    name: "Supabase URL",
+    provider: "supabase",
+    severity: "low",
+    pattern: /https:\/\/[a-z0-9]{20}\.supabase\.co/,
+    description: "Supabase project URL. The unique identifier for your Supabase project.",
+    recommendation: "Exposure is low-risk, but combine with anon key check to assess full exposure surface."
+  },
+  {
+    id: "SP-039",
+    name: "Azure Storage Connection String",
+    provider: "azure",
+    severity: "critical",
+    pattern: /DefaultEndpointsProtocol=https;AccountName=[^;]+;AccountKey=[A-Za-z0-9+/=]{88}/,
+    description: "Azure Storage Account connection string. Grants full read/write access to all blobs, queues, and tables.",
+    recommendation: "Rotate in Azure Portal > Storage Account > Access Keys. Use Managed Identity or SAS tokens instead."
+  },
+  {
+    id: "SP-040",
+    name: "Azure Subscription Key",
+    provider: "azure",
+    severity: "high",
+    pattern: /(?:Ocp-Apim-Subscription-Key|azure[_-]?subscription[_-]?key)['":\s=]+([A-Za-z0-9]{32})/i,
+    description: "Azure API Management subscription key.",
+    recommendation: "Rotate in Azure API Management portal."
+  },
+  {
+    id: "SP-041",
+    name: "Azure AD Client Secret",
+    provider: "azure",
+    severity: "critical",
+    pattern: /(?:AZURE_CLIENT_SECRET|azure[_-]?client[_-]?secret)['":\s=]+([A-Za-z0-9~.@-]{34,40})/i,
+    description: "Azure Active Directory application client secret. Grants OAuth access as the application.",
+    recommendation: "Rotate in Azure AD > App Registrations > Certificates & Secrets."
+  },
+  {
+    id: "SP-042",
+    name: "Cloudflare API Token",
+    provider: "cloudflare",
+    severity: "critical",
+    pattern: /(?:CLOUDFLARE_API_TOKEN|CF_API_TOKEN)['":\s=]+([A-Za-z0-9_-]{40})/i,
+    description: "Cloudflare API token. Grants access to DNS, Workers, Pages, and account settings.",
+    recommendation: "Rotate at dash.cloudflare.com/profile/api-tokens. Use scoped tokens with minimum permissions."
+  },
+  {
+    id: "SP-043",
+    name: "Cloudflare API Key (Global)",
+    provider: "cloudflare",
+    severity: "critical",
+    pattern: /(?:CLOUDFLARE_API_KEY|CF_API_KEY)['":\s=]+([a-f0-9]{37})/i,
+    description: "Cloudflare Global API Key. Grants full account access \u2014 more dangerous than API tokens.",
+    recommendation: "Rotate at dash.cloudflare.com/profile/api-tokens. Prefer scoped API tokens over global keys."
+  },
+  {
+    id: "SP-044",
+    name: "Cloudflare Workers KV Namespace",
+    provider: "cloudflare",
+    severity: "low",
+    pattern: /(?:KV_NAMESPACE_ID|CLOUDFLARE_KV_NAMESPACE)['":\s=]+([a-f0-9]{32})/i,
+    description: "Cloudflare Workers KV namespace identifier.",
+    recommendation: "Low risk alone, but combined with API credentials allows data access."
+  },
+  {
+    id: "SP-045",
+    name: "Vercel API Token",
+    provider: "vercel",
+    severity: "critical",
+    pattern: /(?:VERCEL_TOKEN|vercel[_-]token)['":\s=]+([A-Za-z0-9]{24})/i,
+    description: "Vercel deployment API token. Grants ability to deploy, manage domains, and access secrets.",
+    recommendation: "Rotate at vercel.com/account/tokens."
+  },
+  {
+    id: "SP-046",
+    name: "Vercel Access Token",
+    provider: "vercel",
+    severity: "critical",
+    pattern: /vercel_[A-Za-z0-9]{40,60}/i,
+    description: "Vercel access token for CLI or API authentication.",
+    recommendation: "Rotate at vercel.com/account/tokens."
+  },
+  {
+    id: "SP-047",
+    name: "DigitalOcean Personal Access Token",
+    provider: "digitalocean",
+    severity: "critical",
+    pattern: /dop_v1_[a-f0-9]{64}/,
+    description: "DigitalOcean personal access token. Grants full account access to droplets, databases, and storage.",
+    recommendation: "Rotate at cloud.digitalocean.com/account/api/tokens."
+  },
+  {
+    id: "SP-048",
+    name: "Railway Token",
+    provider: "railway",
+    severity: "high",
+    pattern: /(?:RAILWAY_TOKEN|railway[_-]token)['":\s=]+([A-Za-z0-9_-]{30,50})/i,
+    description: "Railway deployment platform API token.",
+    recommendation: "Rotate at railway.app/account/tokens."
+  },
+  {
+    id: "SP-049",
+    name: "Fly.io API Token",
+    provider: "flyio",
+    severity: "high",
+    pattern: /fo1_[A-Za-z0-9_-]{40,80}/,
+    description: "Fly.io API token for machine deployment and management.",
+    recommendation: "Rotate with: flyctl tokens revoke <token>"
+  },
+  // ── Payment Providers ──
+  {
+    id: "SP-050",
+    name: "Stripe Secret Key (Live)",
+    provider: "stripe",
+    severity: "critical",
+    pattern: /sk_live_[A-Za-z0-9]{24,100}/,
+    description: "Stripe live-mode secret key. Grants full access to create charges, issue refunds, and access customer data.",
+    recommendation: "Rotate immediately at dashboard.stripe.com/apikeys. Never expose in client code."
+  },
+  {
+    id: "SP-051",
+    name: "Stripe Publishable Key (Live)",
+    provider: "stripe",
+    severity: "low",
+    pattern: /pk_live_[A-Za-z0-9]{24,100}/,
+    description: "Stripe live publishable key. This is meant to be public for frontend use.",
+    recommendation: "This key is designed to be public. Ensure it is not confused with the secret key."
+  },
+  {
+    id: "SP-052",
+    name: "Stripe Restricted Key (Live)",
+    provider: "stripe",
+    severity: "high",
+    pattern: /rk_live_[A-Za-z0-9]{24,100}/,
+    description: "Stripe live restricted key with limited permissions. Scope depends on configuration.",
+    recommendation: "Rotate at dashboard.stripe.com/apikeys. Audit which permissions are granted."
+  },
+  {
+    id: "SP-053",
+    name: "Stripe Webhook Secret",
+    provider: "stripe",
+    severity: "high",
+    pattern: /whsec_[A-Za-z0-9]{32,60}/,
+    description: "Stripe webhook endpoint signing secret. Allows forging webhook events.",
+    recommendation: "Rotate webhook secret at dashboard.stripe.com/webhooks. Keep server-side only."
+  },
+  {
+    id: "SP-054",
+    name: "PayPal Client Secret",
+    provider: "paypal",
+    severity: "critical",
+    pattern: /(?:PAYPAL_CLIENT_SECRET|paypal[_-]secret)['":\s=]+([A-Za-z0-9_-]{60,80})/i,
+    description: "PayPal REST API client secret. Grants ability to process payments and access merchant data.",
+    recommendation: "Rotate at developer.paypal.com/developer/applications."
+  },
+  {
+    id: "SP-055",
+    name: "PayPal Access Token",
+    provider: "paypal",
+    severity: "high",
+    pattern: /(?:A21AA|Bearer\s+)[A-Za-z0-9_-]{80,120}/,
+    description: "PayPal OAuth access token. Short-lived but grants API access to payment operations.",
+    recommendation: "Access tokens expire but should not be cached in client code."
+  },
+  {
+    id: "SP-056",
+    name: "Plaid Secret Key",
+    provider: "plaid",
+    severity: "critical",
+    pattern: /(?:PLAID_SECRET|plaid[_-]secret)['":\s=]+([a-f0-9]{30,40})/i,
+    description: "Plaid financial data API secret key. Grants access to bank account and transaction data.",
+    recommendation: "Rotate at dashboard.plaid.com/team/keys."
+  },
+  {
+    id: "SP-057",
+    name: "Plaid Client ID",
+    provider: "plaid",
+    severity: "medium",
+    pattern: /(?:PLAID_CLIENT_ID|plaid[_-]client[_-]id)['":\s=]+([a-f0-9]{24})/i,
+    description: "Plaid application client ID.",
+    recommendation: "Low risk alone, but combined with secret key grants bank data access."
+  },
+  {
+    id: "SP-058",
+    name: "Square Access Token",
+    provider: "square",
+    severity: "critical",
+    pattern: /(?:EAA|sq0atp-)[A-Za-z0-9_-]{22,44}/,
+    description: "Square payment processing access token.",
+    recommendation: "Rotate at developer.squareup.com/apps."
+  },
+  {
+    id: "SP-059",
+    name: "Shopify Admin API Key",
+    provider: "shopify",
+    severity: "critical",
+    pattern: /shpat_[a-fA-F0-9]{32}/,
+    description: "Shopify Admin API access token. Grants full store management capabilities.",
+    recommendation: "Revoke at Shopify Admin > Settings > Apps and Sales Channels > API."
+  },
+  {
+    id: "SP-060",
+    name: "Shopify Storefront Token",
+    provider: "shopify",
+    severity: "medium",
+    pattern: /shpss_[a-fA-F0-9]{32}/,
+    description: "Shopify Storefront API access token. More limited than admin token.",
+    recommendation: "Designed for client use but ensure scopes are minimum necessary."
+  },
+  // ── Communication / Messaging ──
+  {
+    id: "SP-061",
+    name: "Slack Bot Token",
+    provider: "slack",
+    severity: "high",
+    pattern: /xoxb-[0-9]+-[0-9]+-[A-Za-z0-9]+/,
+    description: "Slack bot OAuth token. Grants access to post messages, read channels, and perform bot actions.",
+    recommendation: "Rotate at api.slack.com/apps. Scope tokens to minimum required permissions."
+  },
+  {
+    id: "SP-062",
+    name: "Slack User Token",
+    provider: "slack",
+    severity: "critical",
+    pattern: /xoxp-[0-9]+-[0-9]+-[0-9]+-[A-Za-z0-9]+/,
+    description: "Slack user OAuth token. Acts as the user \u2014 can read all accessible messages and DMs.",
+    recommendation: "Rotate at api.slack.com/apps. User tokens should never be in application code."
+  },
+  {
+    id: "SP-063",
+    name: "Slack App-Level Token",
+    provider: "slack",
+    severity: "high",
+    pattern: /xapp-[0-9]+-[A-Za-z0-9]+-[A-Za-z0-9]+/,
+    description: "Slack app-level token for socket mode and org-wide operations.",
+    recommendation: "Rotate at api.slack.com/apps."
+  },
+  {
+    id: "SP-064",
+    name: "Slack Webhook URL",
+    provider: "slack",
+    severity: "medium",
+    pattern: /https:\/\/hooks\.slack\.com\/services\/T[A-Z0-9]+\/B[A-Z0-9]+\/[A-Za-z0-9]+/,
+    description: "Slack incoming webhook URL. Allows posting messages to a specific channel.",
+    recommendation: "Rotate at api.slack.com/apps > Incoming Webhooks. Treat as sensitive."
+  },
+  {
+    id: "SP-065",
+    name: "Discord Bot Token",
+    provider: "discord",
+    severity: "critical",
+    pattern: /[MN][A-Za-z0-9_-]{23}\.[\w-]{6}\.[\w-]{27,38}/,
+    description: "Discord bot token. Grants full bot account access \u2014 can read all visible messages and take actions.",
+    recommendation: "Regenerate at discord.com/developers/applications. Immediately revoke if exposed."
+  },
+  {
+    id: "SP-066",
+    name: "Discord Webhook URL",
+    provider: "discord",
+    severity: "medium",
+    pattern: /https:\/\/discord(?:app)?\.com\/api\/webhooks\/[0-9]+\/[A-Za-z0-9_-]+/,
+    description: "Discord webhook URL. Allows posting to a channel without a bot account.",
+    recommendation: "Delete and recreate the webhook at the Discord channel settings."
+  },
+  {
+    id: "SP-067",
+    name: "Discord Client Secret",
+    provider: "discord",
+    severity: "high",
+    pattern: /(?:DISCORD_CLIENT_SECRET|discord[_-]secret)['":\s=]+([A-Za-z0-9_-]{32})/i,
+    description: "Discord OAuth application client secret.",
+    recommendation: "Rotate at discord.com/developers/applications."
+  },
+  {
+    id: "SP-068",
+    name: "Twilio Account SID",
+    provider: "twilio",
+    severity: "medium",
+    pattern: /AC[a-fA-F0-9]{32}/,
+    description: "Twilio Account SID. Identifier needed with auth token to access SMS, voice, and messaging APIs.",
+    recommendation: "The SID alone is low risk \u2014 it requires the auth token to authenticate."
+  },
+  {
+    id: "SP-069",
+    name: "Twilio Auth Token",
+    provider: "twilio",
+    severity: "critical",
+    pattern: /(?:TWILIO_AUTH_TOKEN|twilio[_-]auth[_-]token)['":\s=]+([a-fA-F0-9]{32})/i,
+    description: "Twilio auth token. Combined with Account SID grants full access to messaging, phone numbers, and billing.",
+    recommendation: "Rotate at console.twilio.com. Enable API key authentication instead of master auth token."
+  },
+  {
+    id: "SP-070",
+    name: "Twilio API Key Secret",
+    provider: "twilio",
+    severity: "high",
+    pattern: /(?:SK[a-fA-F0-9]{32})/,
+    description: "Twilio API Key SID (more restricted than auth token, still sensitive).",
+    recommendation: "Rotate at console.twilio.com/user/api-keys."
+  },
+  {
+    id: "SP-071",
+    name: "SendGrid API Key",
+    provider: "sendgrid",
+    severity: "high",
+    pattern: /SG\.[A-Za-z0-9_-]{22,30}\.[A-Za-z0-9_-]{43,50}/,
+    description: "SendGrid email API key. Grants ability to send transactional email at your expense.",
+    recommendation: "Rotate at app.sendgrid.com/settings/api_keys."
+  },
+  {
+    id: "SP-072",
+    name: "Resend API Key",
+    provider: "resend",
+    severity: "high",
+    pattern: /re_[A-Za-z0-9_]{36,40}/,
+    description: "Resend transactional email API key.",
+    recommendation: "Rotate at resend.com/api-keys."
+  },
+  {
+    id: "SP-073",
+    name: "Mailgun API Key",
+    provider: "mailgun",
+    severity: "high",
+    pattern: /key-[a-fA-F0-9]{32}/,
+    description: "Mailgun private API key for sending and receiving email.",
+    recommendation: "Rotate at app.mailgun.com/app/account/security/api_keys."
+  },
+  {
+    id: "SP-074",
+    name: "Mailchimp API Key",
+    provider: "mailchimp",
+    severity: "high",
+    pattern: /[0-9a-f]{32}-us\d{1,2}/,
+    description: "Mailchimp API key. Grants access to mailing lists, campaigns, and subscriber data.",
+    recommendation: "Rotate at account.mailchimp.com/settings/api-keys."
+  },
+  // ── Developer Tools ──
+  {
+    id: "SP-075",
+    name: "GitHub Personal Access Token (Classic)",
+    provider: "github",
+    severity: "critical",
+    pattern: /ghp_[A-Za-z0-9]{36}/,
+    description: "GitHub classic personal access token. Scope depends on permissions granted when created.",
+    recommendation: "Revoke at github.com/settings/tokens. GitHub automatically detects and alerts on these."
+  },
+  {
+    id: "SP-076",
+    name: "GitHub Fine-Grained Token",
+    provider: "github",
+    severity: "critical",
+    pattern: /github_pat_[A-Za-z0-9_]{82}/,
+    description: "GitHub fine-grained personal access token with repository-level permissions.",
+    recommendation: "Revoke at github.com/settings/tokens."
+  },
+  {
+    id: "SP-077",
+    name: "GitHub OAuth App Token",
+    provider: "github",
+    severity: "high",
+    pattern: /gho_[A-Za-z0-9]{36}/,
+    description: "GitHub OAuth app token. Grants access as the user who authorized the app.",
+    recommendation: "Revoke at github.com/settings/applications."
+  },
+  {
+    id: "SP-078",
+    name: "GitHub Actions Token",
+    provider: "github",
+    severity: "high",
+    pattern: /ghs_[A-Za-z0-9]{36}/,
+    description: "GitHub Actions installation token. Short-lived but should not appear in artifacts.",
+    recommendation: "These expire within an hour but should not be logged or exposed in build artifacts."
+  },
+  {
+    id: "SP-079",
+    name: "GitHub App Private Key",
+    provider: "github",
+    severity: "critical",
+    pattern: /ghv_[A-Za-z0-9]{36}/,
+    description: "GitHub repository-scoped token from a GitHub App installation.",
+    recommendation: "Revoke via GitHub App settings."
+  },
+  {
+    id: "SP-080",
+    name: "npm Publish Token",
+    provider: "npm",
+    severity: "critical",
+    pattern: /npm_[A-Za-z0-9]{36}/,
+    description: "npm publish access token. Grants ability to publish packages under your account \u2014 supply chain attack vector.",
+    recommendation: "Revoke at npmjs.com/settings/tokens. This is the highest risk secret for package maintainers."
+  },
+  {
+    id: "SP-081",
+    name: "PyPI API Token",
+    provider: "pypi",
+    severity: "critical",
+    pattern: /pypi-[A-Za-z0-9_-]{32,80}/,
+    description: "PyPI package publish token. Grants ability to publish Python packages \u2014 supply chain attack vector.",
+    recommendation: "Revoke at pypi.org/manage/account/token. Use scoped tokens per-project."
+  },
+  // ── Databases ──
+  {
+    id: "SP-082",
+    name: "PostgreSQL Connection String",
+    provider: "database",
+    severity: "critical",
+    pattern: /postgres(?:ql)?:\/\/[^:@\s]+:[^@\s]+@[^/\s]+\/[^\s"']+/i,
+    description: "PostgreSQL connection string with embedded credentials.",
+    recommendation: "Rotate database credentials. Use connection poolers (PgBouncer, Supabase Pooler) and secrets managers."
+  },
+  {
+    id: "SP-083",
+    name: "MySQL Connection String",
+    provider: "database",
+    severity: "critical",
+    pattern: /mysql:\/\/[^:@\s]+:[^@\s]+@[^/\s]+\/[^\s"']+/i,
+    description: "MySQL connection string with embedded credentials.",
+    recommendation: "Rotate credentials. Never include database URLs in client code."
+  },
+  {
+    id: "SP-084",
+    name: "MongoDB Connection String",
+    provider: "database",
+    severity: "critical",
+    pattern: /mongodb(?:\+srv)?:\/\/[^:@\s]+:[^@\s]+@[^\s"']+/i,
+    description: "MongoDB connection string with embedded credentials.",
+    recommendation: "Rotate credentials. Enable IP allowlisting. Use MongoDB Atlas connection string with IAM auth."
+  },
+  {
+    id: "SP-085",
+    name: "Redis Connection String",
+    provider: "database",
+    severity: "high",
+    pattern: /redis(?:s)?:\/\/(?:[^:@\s]+:[^@\s]+@)?[^/\s]+(?::\d+)?/i,
+    description: "Redis connection string, potentially with authentication credentials.",
+    recommendation: "Enable Redis AUTH. Use TLS (rediss://). Do not expose Redis to the public internet."
+  },
+  {
+    id: "SP-086",
+    name: "PlanetScale Service Token",
+    provider: "planetscale",
+    severity: "critical",
+    pattern: /pscale_tkn_[A-Za-z0-9_]{32,50}/,
+    description: "PlanetScale database service token.",
+    recommendation: "Rotate at app.planetscale.com/settings/service-tokens."
+  },
+  {
+    id: "SP-087",
+    name: "Neon Database URL",
+    provider: "neon",
+    severity: "critical",
+    pattern: /postgresql:\/\/[^:]+:[^@]+@[a-z0-9-]+\.(?:us-east-\d|eu-central-\d)\.aws\.neon\.tech\/[^\s"']+/,
+    description: "Neon serverless PostgreSQL connection URL with credentials.",
+    recommendation: "Rotate credentials at console.neon.tech. Use connection pooling endpoint."
+  },
+  {
+    id: "SP-088",
+    name: "Turso Database URL",
+    provider: "turso",
+    severity: "high",
+    pattern: /libsql:\/\/[a-z0-9-]+-[a-z0-9]+\.turso\.io/,
+    description: "Turso edge SQLite database connection URL.",
+    recommendation: "Combine with auth token check. Rotate at app.turso.tech."
+  },
+  {
+    id: "SP-089",
+    name: "Turso Auth Token",
+    provider: "turso",
+    severity: "high",
+    pattern: /(?:TURSO_AUTH_TOKEN|turso[_-]token)['":\s=]+([A-Za-z0-9_-]{100,200})/i,
+    description: "Turso database auth token.",
+    recommendation: "Rotate at app.turso.tech/databases."
+  },
+  // ── Analytics / Monitoring ──
+  {
+    id: "SP-090",
+    name: "Sentry DSN",
+    provider: "sentry",
+    severity: "low",
+    pattern: /https:\/\/[a-fA-F0-9]{32}@[a-z0-9]+\.ingest\.sentry\.io\/[0-9]+/,
+    description: "Sentry Data Source Name. Can receive arbitrary error events and expose error data to unauthorized parties.",
+    recommendation: "Rate-limit the DSN. Consider using Sentry Security Headers to restrict event submission."
+  },
+  {
+    id: "SP-091",
+    name: "Datadog API Key",
+    provider: "datadog",
+    severity: "high",
+    pattern: /(?:DD_API_KEY|DATADOG_API_KEY)['":\s=]+([a-fA-F0-9]{32})/i,
+    description: "Datadog API key for submitting metrics, logs, and events.",
+    recommendation: "Rotate at app.datadoghq.com/organization-settings/api-keys."
+  },
+  {
+    id: "SP-092",
+    name: "Datadog App Key",
+    provider: "datadog",
+    severity: "high",
+    pattern: /(?:DD_APP_KEY|DATADOG_APP_KEY)['":\s=]+([a-fA-F0-9]{40})/i,
+    description: "Datadog application key for querying and managing Datadog resources.",
+    recommendation: "Rotate at app.datadoghq.com/organization-settings/application-keys."
+  },
+  {
+    id: "SP-093",
+    name: "New Relic License Key",
+    provider: "newrelic",
+    severity: "high",
+    pattern: /(?:NEW_RELIC_LICENSE_KEY|NRLIC)['":\s=]+([A-Za-z0-9]{40})/i,
+    description: "New Relic ingest license key for APM, logs, and infrastructure.",
+    recommendation: "Rotate at one.newrelic.com/api-keys."
+  },
+  {
+    id: "SP-094",
+    name: "PostHog API Key",
+    provider: "posthog",
+    severity: "medium",
+    pattern: /phc_[A-Za-z0-9]{43}/,
+    description: "PostHog project API key. Client-side analytics key \u2014 can be semi-public but controls data ingest.",
+    recommendation: "This key is typically safe on the client, but ensure project-level access controls are configured."
+  },
+  {
+    id: "SP-095",
+    name: "Amplitude API Key",
+    provider: "amplitude",
+    severity: "medium",
+    pattern: /(?:AMPLITUDE_API_KEY|amplitude[_-]api[_-]key)['":\s=]+([a-fA-F0-9]{32})/i,
+    description: "Amplitude analytics project API key.",
+    recommendation: "Low risk for the API key, but the secret key should be server-side only."
+  },
+  {
+    id: "SP-096",
+    name: "Mixpanel Token",
+    provider: "mixpanel",
+    severity: "low",
+    pattern: /(?:MIXPANEL_TOKEN|NEXT_PUBLIC_MIXPANEL)['":\s=]+([a-fA-F0-9]{32})/i,
+    description: "Mixpanel analytics project token. Designed to be public for event tracking.",
+    recommendation: "Project token is safe to be public. Keep the project secret server-side."
+  },
+  {
+    id: "SP-097",
+    name: "Segment Write Key",
+    provider: "segment",
+    severity: "medium",
+    pattern: /(?:SEGMENT_WRITE_KEY|analytics\.load\()['":\s(]+([A-Za-z0-9]{20,30})/i,
+    description: "Segment analytics write key. Allows sending arbitrary events to your workspace.",
+    recommendation: "Client-side write keys are semi-public, but server write keys should be kept private."
+  },
+  // ── Search and Data ──
+  {
+    id: "SP-098",
+    name: "Algolia App ID & API Key",
+    provider: "algolia",
+    severity: "medium",
+    pattern: /(?:ALGOLIA_API_KEY|NEXT_PUBLIC_ALGOLIA_API_KEY)['":\s=]+([A-Za-z0-9]{32})/i,
+    description: "Algolia search API key. Admin key grants full index management; search-only key is safe to expose.",
+    recommendation: "Use search-only API keys on the client. Rotate admin keys at algolia.com/account/api-keys."
+  },
+  {
+    id: "SP-099",
+    name: "Algolia Admin API Key",
+    provider: "algolia",
+    severity: "critical",
+    pattern: /(?:ALGOLIA_ADMIN_API_KEY)['":\s=]+([A-Za-z0-9]{32})/i,
+    description: "Algolia admin API key. Grants full index management including delete operations.",
+    recommendation: "Never expose admin key on client. Rotate at algolia.com/account/api-keys."
+  },
+  {
+    id: "SP-100",
+    name: "Mapbox Access Token",
+    provider: "mapbox",
+    severity: "medium",
+    pattern: /pk\.[a-zA-Z0-9.]+\.[a-zA-Z0-9_-]+/,
+    description: "Mapbox public access token. Designed for client use but can be abused for quota theft.",
+    recommendation: "Restrict token by URL in Mapbox account settings."
+  },
+  // ── Cryptographic / Generic ──
+  {
+    id: "SP-101",
+    name: "RSA Private Key",
+    provider: "cryptographic",
+    severity: "critical",
+    pattern: /-----BEGIN RSA PRIVATE KEY-----/,
+    description: "RSA private key embedded in source. Can be used for decryption or identity impersonation.",
+    recommendation: "Remove immediately. Use secrets managers (AWS Secrets Manager, Vault, Doppler)."
+  },
+  {
+    id: "SP-102",
+    name: "EC Private Key",
+    provider: "cryptographic",
+    severity: "critical",
+    pattern: /-----BEGIN EC PRIVATE KEY-----/,
+    description: "Elliptic curve private key embedded in source.",
+    recommendation: "Remove immediately. Rotate the key pair and audit for any usage."
+  },
+  {
+    id: "SP-103",
+    name: "PKCS8 Private Key",
+    provider: "cryptographic",
+    severity: "critical",
+    pattern: /-----BEGIN PRIVATE KEY-----/,
+    description: "PKCS#8 private key in unencrypted PEM format.",
+    recommendation: "Remove immediately. Use environment variables with proper secret management."
+  },
+  {
+    id: "SP-104",
+    name: "PGP Private Key",
+    provider: "cryptographic",
+    severity: "critical",
+    pattern: /-----BEGIN PGP PRIVATE KEY BLOCK-----/,
+    description: "PGP/GPG private key embedded in source.",
+    recommendation: "Remove and revoke the key at your keyserver."
+  },
+  {
+    id: "SP-105",
+    name: "Generic JWT Secret",
+    provider: "generic",
+    severity: "high",
+    pattern: /(?:JWT_SECRET|jwt[_-]secret|JWT_SIGNING_KEY)['":\s=]+["']?([A-Za-z0-9_+/=-]{32,})/i,
+    description: "JWT signing secret. Anyone with this secret can forge valid authentication tokens for your application.",
+    recommendation: "Rotate the secret and invalidate all existing tokens. Use asymmetric keys (RS256/ES256) instead of symmetric."
+  },
+  {
+    id: "SP-106",
+    name: "Generic API Secret",
+    provider: "generic",
+    severity: "high",
+    pattern: /(?:API_SECRET|app[_-]secret|CLIENT_SECRET)['":\s=]+["']?([A-Za-z0-9_+/=.-]{32,})/i,
+    description: "Generic application secret or client secret.",
+    recommendation: "Audit the usage of this secret and rotate if exposed."
+  },
+  {
+    id: "SP-107",
+    name: "Generic Webhook Secret",
+    provider: "generic",
+    severity: "high",
+    pattern: /(?:WEBHOOK_SECRET|webhook[_-]signing[_-]key)['":\s=]+["']?([A-Za-z0-9_+/=-]{32,})/i,
+    description: "Webhook signing secret. Allows forging webhook payloads from third-party services.",
+    recommendation: "Rotate the webhook secret at the originating service."
+  },
+  // ── Social Platforms ──
+  {
+    id: "SP-108",
+    name: "Twitter/X Bearer Token",
+    provider: "twitter",
+    severity: "high",
+    pattern: /AAAAAAAAAAAAAAAAAAAAAA[A-Za-z0-9%]+/,
+    description: "Twitter/X API v2 bearer token. Grants read access to public Twitter data.",
+    recommendation: "Rotate at developer.twitter.com/en/apps."
+  },
+  {
+    id: "SP-109",
+    name: "Twitter API Key",
+    provider: "twitter",
+    severity: "high",
+    pattern: /(?:TWITTER_API_KEY|TWITTER_CONSUMER_KEY)['":\s=]+([A-Za-z0-9]{25})/i,
+    description: "Twitter/X API consumer key.",
+    recommendation: "Rotate at developer.twitter.com/en/apps."
+  },
+  {
+    id: "SP-110",
+    name: "Twitter API Secret",
+    provider: "twitter",
+    severity: "critical",
+    pattern: /(?:TWITTER_API_SECRET|TWITTER_CONSUMER_SECRET)['":\s=]+([A-Za-z0-9]{50})/i,
+    description: "Twitter/X API consumer secret. Combined with key grants OAuth application access.",
+    recommendation: "Rotate at developer.twitter.com/en/apps. Required to regenerate if compromised."
+  },
+  {
+    id: "SP-111",
+    name: "HubSpot Private App Token",
+    provider: "hubspot",
+    severity: "high",
+    pattern: /pat-(?:na|eu)\d-[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/,
+    description: "HubSpot private app access token. Grants CRM data access.",
+    recommendation: "Rotate at app.hubspot.com/private-apps."
+  },
+  {
+    id: "SP-112",
+    name: "Notion Integration Token",
+    provider: "notion",
+    severity: "high",
+    pattern: /secret_[A-Za-z0-9]{43}/,
+    description: "Notion internal integration token. Grants access to all pages shared with the integration.",
+    recommendation: "Rotate at notion.so/my-integrations."
+  },
+  {
+    id: "SP-113",
+    name: "Airtable API Key",
+    provider: "airtable",
+    severity: "high",
+    pattern: /(?:AIRTABLE_API_KEY)['":\s=]+([A-Za-z0-9]{17})/i,
+    description: "Airtable personal API key. Grants access to all bases the account can access.",
+    recommendation: "Rotate at airtable.com/account. Prefer scoped personal access tokens."
+  },
+  {
+    id: "SP-114",
+    name: "Airtable Personal Access Token",
+    provider: "airtable",
+    severity: "high",
+    pattern: /pat[A-Za-z0-9]{14}\.[a-fA-F0-9]{64}/,
+    description: "Airtable scoped personal access token.",
+    recommendation: "Rotate at airtable.com/create/tokens."
+  },
+  {
+    id: "SP-115",
+    name: "Linear API Key",
+    provider: "linear",
+    severity: "high",
+    pattern: /lin_api_[A-Za-z0-9]{40}/,
+    description: "Linear project management API key. Grants access to issues, projects, and teams.",
+    recommendation: "Rotate at linear.app/settings/api."
+  },
+  // ── Infrastructure / DevOps ──
+  {
+    id: "SP-116",
+    name: "HashiCorp Vault Token",
+    provider: "hashicorp",
+    severity: "critical",
+    pattern: /(?:VAULT_TOKEN|hvs\.[A-Za-z0-9]+)/,
+    description: "HashiCorp Vault service token. Grants access to secrets stored in Vault.",
+    recommendation: "Revoke with vault token revoke. Enable token TTLs and audit logging."
+  },
+  {
+    id: "SP-117",
+    name: "Kubernetes Service Account Token",
+    provider: "kubernetes",
+    severity: "critical",
+    pattern: /eyJhbGciOiJSUzI1NiIsImtpZCI[A-Za-z0-9_-]+\.eyJpc3MiOiJrdWJlcm5ldGVzL3NlcnZpY2VhY2NvdW50/,
+    description: "Kubernetes service account JWT token. Grants API server access within the cluster.",
+    recommendation: "Rotate the service account token. Use short-lived projected tokens (TokenRequest API)."
+  },
+  {
+    id: "SP-118",
+    name: "Cloudinary URL",
+    provider: "cloudinary",
+    severity: "high",
+    pattern: /cloudinary:\/\/[0-9]+:[A-Za-z0-9_-]+@[a-z0-9_]+/,
+    description: "Cloudinary media storage URL with API credentials.",
+    recommendation: "Rotate at cloudinary.com/console. This grants upload and transformation access."
+  },
+  {
+    id: "SP-119",
+    name: "Upstash Redis Token",
+    provider: "upstash",
+    severity: "high",
+    pattern: /(?:UPSTASH_REDIS_REST_TOKEN|upstash[_-]token)['":\s=]+([A-Za-z0-9_-]{50,100})/i,
+    description: "Upstash serverless Redis REST API token.",
+    recommendation: "Rotate at console.upstash.com."
+  },
+  {
+    id: "SP-120",
+    name: "Upstash QStash Token",
+    provider: "upstash",
+    severity: "high",
+    pattern: /(?:QSTASH_TOKEN)['":\s=]+([A-Za-z0-9_-]{100,200})/i,
+    description: "Upstash QStash serverless message queue token.",
+    recommendation: "Rotate at console.upstash.com/qstash."
+  },
+  // ── Additional AI/ML Platforms ──
+  {
+    id: "SP-121",
+    name: "Portkey API Key",
+    provider: "portkey",
+    severity: "medium",
+    pattern: /(?:PORTKEY_API_KEY)['":\s=]+([A-Za-z0-9_-]{40,60})/i,
+    description: "Portkey AI gateway API key.",
+    recommendation: "Rotate at app.portkey.ai/settings."
+  },
+  {
+    id: "SP-122",
+    name: "Langfuse Secret Key",
+    provider: "langfuse",
+    severity: "medium",
+    pattern: /sk-lf-[A-Za-z0-9_-]{36,50}/,
+    description: "Langfuse LLM observability secret key.",
+    recommendation: "Rotate at cloud.langfuse.com/project/settings."
+  },
+  {
+    id: "SP-123",
+    name: "Weaviate API Key",
+    provider: "weaviate",
+    severity: "high",
+    pattern: /(?:WEAVIATE_API_KEY)['":\s=]+([A-Za-z0-9_-]{32,50})/i,
+    description: "Weaviate vector database API key.",
+    recommendation: "Rotate at the Weaviate Cloud Services console."
+  },
+  {
+    id: "SP-124",
+    name: "Pinecone API Key",
+    provider: "pinecone",
+    severity: "high",
+    pattern: /(?:PINECONE_API_KEY)['":\s=]+([a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12})/i,
+    description: "Pinecone vector database API key. Grants access to vector indices and stored embeddings.",
+    recommendation: "Rotate at app.pinecone.io/organization/api-keys."
+  },
+  {
+    id: "SP-125",
+    name: "Browserbase API Key",
+    provider: "browserbase",
+    severity: "high",
+    pattern: /(?:BROWSERBASE_API_KEY)['":\s=]+([A-Za-z0-9_-]{32,50})/i,
+    description: "Browserbase cloud browser API key for web automation.",
+    recommendation: "Rotate at browserbase.com/settings."
+  },
+  // ── Payments (extended) ──
+  {
+    id: "SP-126",
+    name: "Braintree API Key",
+    provider: "braintree",
+    severity: "critical",
+    pattern: /(?:BRAINTREE_PRIVATE_KEY|braintree[_-]private[_-]key)['":\s=]+([A-Za-z0-9]{32})/i,
+    description: "Braintree payment processing private key.",
+    recommendation: "Rotate at sandbox.braintreegateway.com or braintreegateway.com."
+  },
+  // ── Communication (extended) ──
+  {
+    id: "SP-127",
+    name: "Pusher App Secret",
+    provider: "pusher",
+    severity: "high",
+    pattern: /(?:PUSHER_APP_SECRET)['":\s=]+([a-fA-F0-9]{20})/i,
+    description: "Pusher Channels app secret for server-side event authentication.",
+    recommendation: "Rotate at dashboard.pusher.com."
+  },
+  {
+    id: "SP-128",
+    name: "Ably API Key",
+    provider: "ably",
+    severity: "high",
+    pattern: /[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+:[A-Za-z0-9_+/=]{32,50}/,
+    description: "Ably realtime messaging API key.",
+    recommendation: "Rotate at ably.com/accounts."
+  },
+  {
+    id: "SP-129",
+    name: "Zoom JWT Token",
+    provider: "zoom",
+    severity: "high",
+    pattern: /(?:ZOOM_JWT_TOKEN|zoom[_-]jwt)['":\s=]+([A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+)/i,
+    description: "Zoom JWT application token for Server-to-Server OAuth.",
+    recommendation: "Rotate at marketplace.zoom.us/develop/apps."
+  },
+  // ── Data Platforms ──
+  {
+    id: "SP-130",
+    name: "Elastic Search API Key",
+    provider: "elastic",
+    severity: "high",
+    pattern: /(?:ELASTICSEARCH_API_KEY|elastic[_-]api[_-]key)['":\s=]+([A-Za-z0-9_=]+:{[^}]+})/i,
+    description: "Elasticsearch / Elastic Cloud API key.",
+    recommendation: "Rotate in Kibana > Stack Management > Security > API Keys."
+  },
+  {
+    id: "SP-131",
+    name: "Kafka SASL Password",
+    provider: "kafka",
+    severity: "critical",
+    pattern: /(?:KAFKA_SASL_PASSWORD|kafka[_-]password)['":\s=]+([^\s"']{8,})/i,
+    description: "Apache Kafka SASL authentication password.",
+    recommendation: "Rotate and enable SSL/TLS for Kafka connections."
+  },
+  // ── Observability (extended) ──
+  {
+    id: "SP-132",
+    name: "Axiom API Token",
+    provider: "axiom",
+    severity: "medium",
+    pattern: /xaat-[A-Za-z0-9_-]{36,50}/,
+    description: "Axiom log analytics API token.",
+    recommendation: "Rotate at app.axiom.co/settings/api-tokens."
+  },
+  {
+    id: "SP-133",
+    name: "Grafana API Key",
+    provider: "grafana",
+    severity: "high",
+    pattern: /(?:GRAFANA_API_KEY|grafana[_-]token)['":\s=]+([A-Za-z0-9=]{40,100})/i,
+    description: "Grafana Cloud API key for metrics, logs, and traces.",
+    recommendation: "Rotate at grafana.com/profile/api-keys."
+  },
+  // ── Environment Variable Leaks ──
+  {
+    id: "SP-134",
+    name: "Exposed NEXT_PUBLIC Secret Variable",
+    provider: "nextjs",
+    severity: "high",
+    pattern: /NEXT_PUBLIC_(?:SECRET|KEY|TOKEN|PASSWORD|PRIVATE)[A-Z_]*['":\s=]+["']?[A-Za-z0-9_+/=-]{20,}/i,
+    description: "Variable prefixed NEXT_PUBLIC_ (client-bundle exposure) with a name suggesting it is a secret. NEXT_PUBLIC_ variables are always bundled into the client.",
+    recommendation: "Remove NEXT_PUBLIC_ prefix. Move to server-side environment variables or use Next.js server actions."
+  },
+  {
+    id: "SP-135",
+    name: "Exposed VITE Secret Variable",
+    provider: "vite",
+    severity: "high",
+    pattern: /VITE_(?:SECRET|KEY|TOKEN|PASSWORD|PRIVATE)[A-Z_]*['":\s=]+["']?[A-Za-z0-9_+/=-]{20,}/i,
+    description: "Variable prefixed VITE_ (client-bundle exposure) with a name suggesting it is a secret. VITE_ variables are always bundled into the client.",
+    recommendation: "Remove VITE_ prefix and handle server-side. Use API routes for sensitive operations."
+  },
+  {
+    id: "SP-136",
+    name: "Hardcoded Password Pattern",
+    provider: "generic",
+    severity: "high",
+    pattern: /(?:password|passwd|db_pass|db_password)['":\s=]+["'](?!.*\${)[A-Za-z0-9!@#$%^&*_+=]{8,}/i,
+    description: "Hardcoded password string that does not appear to be a template variable.",
+    recommendation: "Move credentials to environment variables and use a secrets manager."
+  },
+  // ── AI Agent Ecosystem ──
+  {
+    id: "SP-137",
+    name: "Smithery Registry Token",
+    provider: "smithery",
+    severity: "high",
+    pattern: /(?:SMITHERY_API_KEY|smithery[_-]token)['":\s=]+([A-Za-z0-9_-]{30,60})/i,
+    description: "Smithery MCP registry API token. Grants publish access to MCP server packages.",
+    recommendation: "Rotate at smithery.ai/settings. Supply chain risk \u2014 protect publish access."
+  },
+  {
+    id: "SP-138",
+    name: "Cursor API Key",
+    provider: "cursor",
+    severity: "medium",
+    pattern: /(?:CURSOR_API_KEY)['":\s=]+([A-Za-z0-9_-]{30,60})/i,
+    description: "Cursor IDE API integration key.",
+    recommendation: "Rotate at cursor.com/settings."
+  },
+  {
+    id: "SP-139",
+    name: "Vigile API Key",
+    provider: "vigile",
+    severity: "medium",
+    pattern: /vgl_[A-Za-z0-9_-]{40,60}/,
+    description: "Vigile AI API key. Grants access to Vigile scan API and trust registry.",
+    recommendation: "Rotate at vigile.dev/account."
+  },
+  {
+    id: "SP-140",
+    name: "OpenAI API Key (via env)",
+    provider: "openai",
+    severity: "critical",
+    pattern: /(?:OPENAI_API_KEY)['":\s=]+["']?(sk-[A-Za-z0-9_-]{48,})/i,
+    description: "OpenAI API key referenced in an environment variable assignment.",
+    recommendation: "Rotate at platform.openai.com/api-keys. Move to server-side proxy."
+  },
+  {
+    id: "SP-141",
+    name: "Anthropic API Key (via env)",
+    provider: "anthropic",
+    severity: "critical",
+    pattern: /(?:ANTHROPIC_API_KEY)['":\s=]+["']?(sk-ant-api[A-Za-z0-9_-]{90,})/i,
+    description: "Anthropic API key in an environment variable assignment.",
+    recommendation: "Rotate at console.anthropic.com. Never include in client bundles."
+  },
+  // ── Extended Coverage ──
+  {
+    id: "SP-142",
+    name: "Stripe Secret Key (Test)",
+    provider: "stripe",
+    severity: "medium",
+    pattern: /sk_test_[A-Za-z0-9]{24,100}/,
+    description: "Stripe test-mode secret key. Should not be in production bundles.",
+    recommendation: "Test keys should not appear in client code even in development builds."
+  },
+  {
+    id: "SP-143",
+    name: "GitHub App Installation Token",
+    provider: "github",
+    severity: "high",
+    pattern: /ghi_[A-Za-z0-9]{36}/,
+    description: "GitHub App installation token (internal use).",
+    recommendation: "These are short-lived but should not appear in artifacts."
+  },
+  {
+    id: "SP-144",
+    name: "Supabase JWT Secret",
+    provider: "supabase",
+    severity: "critical",
+    pattern: /(?:SUPABASE_JWT_SECRET|JWT_SECRET)['":\s=]+["']?[A-Za-z0-9_+/=-]{32,}/i,
+    description: "JWT signing secret for Supabase Auth. Anyone with this secret can forge valid session tokens.",
+    recommendation: "This secret is set at project creation and cannot be rotated without breaking all sessions."
+  },
+  {
+    id: "SP-145",
+    name: "Firebase Admin Private Key",
+    provider: "firebase",
+    severity: "critical",
+    pattern: /(?:FIREBASE_PRIVATE_KEY)['":\s=]+["']?-----BEGIN (RSA )?PRIVATE KEY/i,
+    description: "Firebase Admin SDK private key. Grants admin-level database and Auth access.",
+    recommendation: "Remove from client code immediately. Firebase Admin SDK must only run server-side."
+  },
+  {
+    id: "SP-146",
+    name: "Google Analytics Measurement ID",
+    provider: "google",
+    severity: "low",
+    pattern: /G-[A-Z0-9]{10}/,
+    description: "Google Analytics 4 Measurement ID. Designed to be public \u2014 included for inventory purposes.",
+    recommendation: "This is public by design but note it for compliance/privacy documentation."
+  },
+  {
+    id: "SP-147",
+    name: "Imagekit Private Key",
+    provider: "imagekit",
+    severity: "high",
+    pattern: /(?:IMAGEKIT_PRIVATE_KEY)['":\s=]+([A-Za-z0-9_-]{30,60})/i,
+    description: "Imagekit.io private API key for image upload and management.",
+    recommendation: "Rotate at imagekit.io/dashboard/developer/api-keys."
+  },
+  {
+    id: "SP-148",
+    name: "ScraperAPI Key",
+    provider: "scraperapi",
+    severity: "medium",
+    pattern: /(?:SCRAPERAPI_KEY|scraperapi[_-]key)['":\s=]+([a-fA-F0-9]{32})/i,
+    description: "ScraperAPI proxy key for web scraping requests.",
+    recommendation: "Rotate at scraperapi.com/dashboard."
+  },
+  {
+    id: "SP-149",
+    name: "Salesforce Connected App Secret",
+    provider: "salesforce",
+    severity: "critical",
+    pattern: /(?:SF_CLIENT_SECRET|SALESFORCE_SECRET)['":\s=]+([A-Za-z0-9_-]{64})/i,
+    description: "Salesforce Connected App client secret. Grants CRM access as the connected application.",
+    recommendation: "Rotate in Salesforce Setup > App Manager."
+  },
+  {
+    id: "SP-150",
+    name: "Generic Bearer Token",
+    provider: "generic",
+    severity: "medium",
+    pattern: /Authorization:\s*Bearer\s+([A-Za-z0-9_-]{40,200})/i,
+    description: "Bearer token hardcoded in Authorization header \u2014 likely a live credential.",
+    recommendation: "Remove hardcoded tokens. Generate tokens at runtime from securely stored credentials."
+  }
+];
+function matchSecrets(text) {
+  const results = [];
+  for (const sp of SECRET_PATTERNS) {
+    const flags = sp.pattern.flags.includes("i") ? "gi" : "g";
+    const globalPattern = new RegExp(sp.pattern.source, flags);
+    for (const m of text.matchAll(globalPattern)) {
+      const matched = m[0];
+      const idx = m.index ?? 0;
+      const start = Math.max(0, idx - 25);
+      const end = Math.min(text.length, idx + matched.length + 25);
+      const context = text.slice(start, end).replace(/\s+/g, " ").trim();
+      results.push({
+        pattern: sp,
+        match: mask(matched),
+        context
+      });
+    }
+  }
+  return results;
+}
+
+// src/scanner/baas/bundle-analyzer.ts
+var MAX_BUNDLE_SIZE = 5 * 1024 * 1024;
+var MAX_BUNDLES = 10;
+var FETCH_TIMEOUT_MS = 15e3;
+function extractScriptSrcs(html, baseUrl) {
+  const srcs = [];
+  const scriptRe = /<script[^>]+src=["']([^"']+)["'][^>]*>/gi;
+  for (const m of html.matchAll(scriptRe)) {
+    const src = m[1];
+    if (!src) continue;
+    if (src.startsWith("data:")) continue;
+    try {
+      const resolved = new URL(src, baseUrl).toString();
+      srcs.push(resolved);
+    } catch {
+    }
+  }
+  return srcs;
+}
+async function fetchWithTimeout(url, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, { signal: controller.signal });
+    return response;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function fetchText(url) {
+  try {
+    const res = await fetchWithTimeout(url, FETCH_TIMEOUT_MS);
+    if (!res.ok) {
+      return { text: "", error: `HTTP ${res.status} for ${url}` };
+    }
+    const contentLength = parseInt(res.headers.get("content-length") ?? "0", 10);
+    if (contentLength > MAX_BUNDLE_SIZE) {
+      return { text: "", error: `Bundle too large (${contentLength} bytes): ${url}` };
+    }
+    const buffer = await res.arrayBuffer();
+    if (buffer.byteLength > MAX_BUNDLE_SIZE) {
+      return { text: "", error: `Bundle exceeds 5 MB limit: ${url}` };
+    }
+    return { text: new TextDecoder().decode(buffer) };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { text: "", error: `Fetch failed for ${url}: ${msg}` };
+  }
+}
+function makeSecretFinding(bundleUrl, matchedId, matchedName, severity, maskedValue, context, index) {
+  return {
+    id: `BU-${String(index + 1).padStart(3, "0")}`,
+    category: "exposed-secret",
+    severity,
+    title: `Exposed ${matchedName} secret in JS bundle`,
+    description: `A ${matchedName} credential was found in a compiled JavaScript bundle at ${bundleUrl}. Secrets baked into frontend bundles are readable by anyone who inspects your app's network traffic or source code.`,
+    evidence: `Pattern: ${matchedId} | Masked value: ${maskedValue} | Context: ${context}`,
+    recommendation: `Move this secret to a server-side environment variable. Never include API keys or tokens in frontend JavaScript. Use a backend proxy or BFF (Backend for Frontend) pattern to make authenticated API calls.`
+  };
+}
+async function analyzeBundles(appUrl) {
+  const errors = [];
+  const findings = [];
+  let bundlesAnalyzed = 0;
+  const baseUrl = appUrl.endsWith("/") ? appUrl : `${appUrl}/`;
+  const { text: html, error: htmlError } = await fetchText(baseUrl);
+  if (htmlError || !html) {
+    errors.push(htmlError ?? `Could not fetch root HTML for ${baseUrl}`);
+    return { url: appUrl, bundlesAnalyzed: 0, findings, errors };
+  }
+  const scriptUrls = extractScriptSrcs(html, baseUrl).slice(0, MAX_BUNDLES);
+  if (scriptUrls.length === 0) {
+    errors.push(`No <script src> tags found in HTML at ${baseUrl}`);
+    return { url: appUrl, bundlesAnalyzed: 0, findings, errors };
+  }
+  let findingIndex = 0;
+  for (const scriptUrl of scriptUrls) {
+    const { text: bundleText, error: fetchError } = await fetchText(scriptUrl);
+    if (fetchError || !bundleText) {
+      errors.push(fetchError ?? `Empty bundle at ${scriptUrl}`);
+      continue;
+    }
+    bundlesAnalyzed++;
+    const matches = matchSecrets(bundleText);
+    for (const secretMatch of matches) {
+      findings.push(
+        makeSecretFinding(
+          scriptUrl,
+          secretMatch.pattern.id,
+          secretMatch.pattern.name,
+          secretMatch.pattern.severity,
+          secretMatch.match,
+          secretMatch.context,
+          findingIndex++
+        )
+      );
+    }
+  }
+  return { url: appUrl, bundlesAnalyzed, findings, errors };
+}
+
+// src/scanner/baas/supabase-scanner.ts
+var FETCH_TIMEOUT_MS2 = 1e4;
+async function fetchWithTimeout2(url, init) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS2);
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function normaliseSupabaseUrl(url) {
+  let u = url.replace(/\/+$/, "");
+  if (!u.startsWith("http")) {
+    u = `https://${u}`;
+  }
+  return u;
+}
+function extractAnonKeyFromFindings(findings) {
+  for (const f of findings) {
+    const ev = f.evidence ?? "";
+    if ((ev.includes("supabase") || ev.includes("SP-022") || ev.includes("SP-023")) && ev.includes("eyJ")) {
+      const jwtMatch = ev.match(/eyJ[A-Za-z0-9_-]+\.eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/);
+      if (jwtMatch) return jwtMatch[0];
+    }
+  }
+  return null;
+}
+async function scanSupabase(opts) {
+  const findings = [];
+  const errors = [];
+  const tablesFound = [];
+  let anonReadExposed = false;
+  let reachable = false;
+  const baseUrl = normaliseSupabaseUrl(opts.projectUrl);
+  try {
+    const res = await fetchWithTimeout2(`${baseUrl}/rest/v1/`, {
+      method: "HEAD"
+    });
+    reachable = res.status === 401 || res.status === 200 || res.status === 403;
+  } catch {
+    errors.push(`Supabase project not reachable at ${baseUrl}`);
+    return { projectUrl: baseUrl, findings, tablesFound, anonReadExposed, reachable, errors };
+  }
+  if (!reachable) {
+    errors.push(`Supabase project returned unexpected status at ${baseUrl}/rest/v1/`);
+    return { projectUrl: baseUrl, findings, tablesFound, anonReadExposed, reachable, errors };
+  }
+  const bundleResult = await analyzeBundles(baseUrl);
+  findings.push(...bundleResult.findings);
+  if (bundleResult.errors.length > 0) {
+    errors.push(...bundleResult.errors.map((e) => `[bundle] ${e}`));
+  }
+  const hasServiceRoleKey = bundleResult.findings.some(
+    (f) => f.evidence?.includes("service_role") || f.evidence?.includes("SP-023")
+  );
+  if (hasServiceRoleKey) {
+    findings.push({
+      id: "SB-005",
+      category: "exposed-secret",
+      severity: "critical",
+      title: "Supabase service_role key exposed in frontend bundle",
+      description: "The Supabase service_role key was found in a JavaScript bundle. This key bypasses all Row Level Security policies and grants full read/write/delete access to every table and storage bucket. This is equivalent to database superuser access.",
+      evidence: "Detected via bundle analysis \u2014 service_role JWT in compiled JS",
+      recommendation: "Rotate the service_role key immediately in Supabase Dashboard > Settings > API. This key must NEVER appear in frontend code. Use it only in server-side functions (Edge Functions, API routes)."
+    });
+  }
+  let anonKey = opts.anonKey ?? null;
+  if (!anonKey) {
+    anonKey = extractAnonKeyFromFindings(bundleResult.findings);
+  }
+  if (!anonKey) {
+    errors.push(
+      "No anon key provided or detected in bundles \u2014 skipping RLS and table enumeration. Pass --supabase-key or ensure the app URL serves JS bundles with the anon key."
+    );
+  }
+  if (anonKey) {
+    try {
+      const tablesRes = await fetchWithTimeout2(`${baseUrl}/rest/v1/`, {
+        headers: {
+          apikey: anonKey,
+          Authorization: `Bearer ${anonKey}`
+        }
+      });
+      if (tablesRes.ok) {
+        try {
+          const schema = await tablesRes.json();
+          const paths = schema.paths ?? {};
+          for (const path of Object.keys(paths)) {
+            const tableName = path.replace(/^\//, "").split("?")[0];
+            if (tableName && !tableName.includes("/")) {
+              tablesFound.push(tableName);
+            }
+          }
+        } catch {
+          errors.push("Could not parse Supabase REST schema response");
+        }
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      errors.push(`Table enumeration failed: ${msg}`);
+    }
+    for (const table of tablesFound) {
+      try {
+        const readRes = await fetchWithTimeout2(
+          `${baseUrl}/rest/v1/${table}?select=*&limit=1`,
+          {
+            headers: {
+              apikey: anonKey,
+              Authorization: `Bearer ${anonKey}`
+            }
+          }
+        );
+        if (readRes.ok) {
+          const body = await readRes.text();
+          if (body.startsWith("[") && body !== "[]") {
+            anonReadExposed = true;
+            findings.push({
+              id: "SB-001",
+              category: "rls-misconfiguration",
+              severity: "critical",
+              title: `RLS disabled: anonymous read on "${table}"`,
+              description: `Table "${table}" returned data via the anon key without any Row Level Security policies. Any user with the anon key (which is public) can read all rows in this table. This is the #1 Supabase security mistake.`,
+              evidence: `GET /rest/v1/${table}?select=*&limit=1 returned 200 with data`,
+              recommendation: `Enable RLS on table "${table}" in Supabase Dashboard > Database > Tables. Add a policy like: CREATE POLICY "auth read" ON "${table}" FOR SELECT USING (auth.uid() = user_id);`
+            });
+          }
+        }
+      } catch {
+      }
+      try {
+        const writeRes = await fetchWithTimeout2(
+          `${baseUrl}/rest/v1/${table}`,
+          {
+            method: "POST",
+            headers: {
+              apikey: anonKey,
+              Authorization: `Bearer ${anonKey}`,
+              "Content-Type": "application/json",
+              Prefer: "return=minimal"
+            },
+            body: JSON.stringify({})
+          }
+        );
+        if (writeRes.status === 400 || writeRes.status === 201 || writeRes.status === 200) {
+          findings.push({
+            id: "SB-006",
+            category: "rls-misconfiguration",
+            severity: "critical",
+            title: `RLS disabled: anonymous write on "${table}"`,
+            description: `Table "${table}" allows INSERT operations via the anon key. The request reached the database layer (RLS did not block it). Even if it failed on a constraint, the lack of RLS means anyone can attempt to write data to this table.`,
+            evidence: `POST /rest/v1/${table} returned ${writeRes.status} (not 401/403)`,
+            recommendation: `Enable RLS on table "${table}" and add INSERT policies. For example: CREATE POLICY "auth insert" ON "${table}" FOR INSERT WITH CHECK (auth.uid() = user_id);`
+          });
+        }
+      } catch {
+      }
+    }
+  }
+  if (anonKey) {
+    try {
+      const authRes = await fetchWithTimeout2(`${baseUrl}/auth/v1/settings`, {
+        headers: {
+          apikey: anonKey,
+          Authorization: `Bearer ${anonKey}`
+        }
+      });
+      if (authRes.ok) {
+        try {
+          const settings = await authRes.json();
+          const autoconfirm = settings.mailer_autoconfirm ?? settings.autoconfirm;
+          if (autoconfirm === true) {
+            findings.push({
+              id: "SB-003",
+              category: "auth-misconfiguration",
+              severity: "medium",
+              title: "Email confirmation disabled (autoconfirm enabled)",
+              description: "Supabase auth is configured to automatically confirm email addresses without requiring the user to click a verification link. This allows attackers to create accounts with any email address, including impersonating legitimate users.",
+              evidence: "GET /auth/v1/settings returned mailer_autoconfirm: true",
+              recommendation: "Disable autoconfirm in Supabase Dashboard > Authentication > Settings > Email Auth. Require email verification for all new signups."
+            });
+          }
+          const disableSignup = settings.disable_signup;
+          if (disableSignup === false) {
+            findings.push({
+              id: "SB-007",
+              category: "auth-misconfiguration",
+              severity: "low",
+              title: "Open signup enabled",
+              description: "Public signup is enabled on this Supabase project. If this is an internal tool or admin panel, open signup allows anyone to create an account.",
+              evidence: "GET /auth/v1/settings returned disable_signup: false",
+              recommendation: "If this project is not meant for public registration, disable signup in Supabase Dashboard > Authentication > Settings."
+            });
+          }
+        } catch {
+          errors.push("Could not parse auth settings response");
+        }
+      }
+    } catch {
+      errors.push("Auth settings endpoint not reachable");
+    }
+  }
+  try {
+    const corsRes = await fetchWithTimeout2(`${baseUrl}/rest/v1/`, {
+      method: "OPTIONS",
+      headers: {
+        Origin: "https://evil-attacker-site.com",
+        "Access-Control-Request-Method": "GET"
+      }
+    });
+    const allowOrigin = corsRes.headers.get("access-control-allow-origin");
+    if (allowOrigin === "*" || allowOrigin === "https://evil-attacker-site.com") {
+      const isReflected = allowOrigin === "https://evil-attacker-site.com";
+      findings.push({
+        id: "SB-004",
+        category: "cors-misconfiguration",
+        severity: "medium",
+        title: isReflected ? "CORS reflects arbitrary origins on REST API" : "CORS wildcard policy on REST API",
+        description: isReflected ? "The Supabase REST API reflects any Origin header back in Access-Control-Allow-Origin, which is functionally equivalent to a wildcard policy but harder to detect." : "The Supabase REST API returns Access-Control-Allow-Origin: * which allows any website to make authenticated requests to your API. Combined with an exposed anon key, this enables cross-origin data access from malicious sites.",
+        evidence: isReflected ? "OPTIONS /rest/v1/ reflected origin: https://evil-attacker-site.com" : "OPTIONS /rest/v1/ returned Access-Control-Allow-Origin: *",
+        recommendation: "Configure allowed origins in Supabase Dashboard > Settings > API. Restrict to your app domain(s) only."
+      });
+    }
+  } catch {
+  }
+  return {
+    projectUrl: baseUrl,
+    findings,
+    tablesFound,
+    anonReadExposed,
+    reachable,
+    errors
+  };
+}
+
+// src/scanner/baas/firebase-scanner.ts
+var FETCH_TIMEOUT_MS3 = 1e4;
+async function fetchWithTimeout3(url, init) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS3);
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function normaliseUrl(url) {
+  let u = url.replace(/\/+$/, "");
+  if (!u.startsWith("http")) {
+    u = `https://${u}`;
+  }
+  return u;
+}
+function extractProjectId(url) {
+  try {
+    const hostname = new URL(url).hostname;
+    const match = hostname.match(/^([^.]+)\.(web\.app|firebaseapp\.com)$/);
+    return match?.[1] ?? null;
+  } catch {
+    return null;
+  }
+}
+function extractConfigFromFindings(findings) {
+  const config = {};
+  for (const f of findings) {
+    const ev = f.evidence ?? "";
+    if (ev.includes("AIzaSy")) {
+      const keyMatch = ev.match(/AIzaSy[A-Za-z0-9_-]{33}/);
+      if (keyMatch) config.apiKey = keyMatch[0];
+    }
+    if (ev.includes("projectId") || ev.includes("firebase")) {
+      const projMatch = ev.match(/["']([a-z0-9-]+)\.firebaseapp\.com["']/);
+      if (projMatch) config.projectId = projMatch[1];
+    }
+    if (ev.includes("storageBucket") || ev.includes(".appspot.com")) {
+      const bucketMatch = ev.match(/([a-z0-9-]+)\.appspot\.com/);
+      if (bucketMatch) config.storageBucket = bucketMatch[0];
+    }
+  }
+  return config;
+}
+async function scanFirebase(opts) {
+  const findings = [];
+  const errors = [];
+  let firestorePublicAccess = false;
+  let rtdbPublicAccess = false;
+  let configExposed = false;
+  let reachable = false;
+  const baseUrl = normaliseUrl(opts.projectUrl);
+  const projectId = opts.projectId ?? extractProjectId(baseUrl);
+  try {
+    const res = await fetchWithTimeout3(baseUrl, { method: "HEAD" });
+    reachable = res.status >= 200 && res.status < 500;
+  } catch {
+    errors.push(`Firebase project not reachable at ${baseUrl}`);
+    return {
+      projectUrl: baseUrl,
+      projectId,
+      findings,
+      firestorePublicAccess,
+      rtdbPublicAccess,
+      configExposed,
+      reachable,
+      errors
+    };
+  }
+  if (!reachable) {
+    errors.push(`Firebase project returned unexpected status at ${baseUrl}`);
+    return {
+      projectUrl: baseUrl,
+      projectId,
+      findings,
+      firestorePublicAccess,
+      rtdbPublicAccess,
+      configExposed,
+      reachable,
+      errors
+    };
+  }
+  const bundleResult = await analyzeBundles(baseUrl);
+  findings.push(...bundleResult.findings);
+  if (bundleResult.errors.length > 0) {
+    errors.push(...bundleResult.errors.map((e) => `[bundle] ${e}`));
+  }
+  const bundleConfig = extractConfigFromFindings(bundleResult.findings);
+  const detectedProjectId = projectId ?? bundleConfig.projectId ?? null;
+  if (bundleConfig.apiKey) {
+    configExposed = true;
+    findings.push({
+      id: "FB-003",
+      category: "exposed-secret",
+      severity: "high",
+      title: "Firebase config object exposed in frontend bundle",
+      description: "The Firebase client configuration (apiKey, projectId, etc.) was found in a JavaScript bundle. While Firebase API keys are designed to be public for client-side use, exposure without App Check enforcement allows abuse: automated account creation, Firestore/RTDB enumeration, and quota exhaustion attacks.",
+      evidence: `Firebase apiKey: ${bundleConfig.apiKey.slice(0, 8)}*** detected in bundle`,
+      recommendation: "Enable Firebase App Check in the Firebase Console to restrict API access to your legitimate app. Configure reCAPTCHA Enterprise or DeviceCheck attestation. Without App Check, anyone with the config can call your Firebase APIs."
+    });
+  }
+  if (detectedProjectId) {
+    const firestoreUrl = `https://firestore.googleapis.com/v1/projects/${detectedProjectId}/databases/(default)/documents`;
+    try {
+      const fsRes = await fetchWithTimeout3(firestoreUrl);
+      if (fsRes.ok) {
+        firestorePublicAccess = true;
+        let docCount = 0;
+        try {
+          const body = await fsRes.json();
+          docCount = body.documents?.length ?? 0;
+        } catch {
+        }
+        findings.push({
+          id: "FB-001",
+          category: "firebase-rules-issue",
+          severity: "critical",
+          title: "Firestore allows unauthenticated read access",
+          description: "The Firestore REST API returned documents without any authentication token. This means Firestore Security Rules are configured with `allow read: if true` or similar permissive rules at the database or collection level. Any data in Firestore is publicly accessible.",
+          evidence: `GET ${firestoreUrl} returned 200` + (docCount > 0 ? ` (${docCount} documents visible)` : ""),
+          recommendation: "Update Firestore Security Rules to require authentication: `allow read: if request.auth != null;` at minimum. Ideally, add per-user rules: `allow read: if request.auth.uid == resource.data.userId;`"
+        });
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      errors.push(`Firestore probe failed: ${msg}`);
+    }
+    try {
+      const writeUrl = `https://firestore.googleapis.com/v1/projects/${detectedProjectId}/databases/(default)/documents/vigile_probe_test`;
+      const writeRes = await fetchWithTimeout3(writeUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          fields: {
+            _vigile_probe: { stringValue: "security_test" }
+          }
+        })
+      });
+      if (writeRes.status === 200) {
+        firestorePublicAccess = true;
+        findings.push({
+          id: "FB-001",
+          category: "firebase-rules-issue",
+          severity: "critical",
+          title: "Firestore allows unauthenticated WRITE access",
+          description: "A document was successfully written to Firestore without any authentication. This means anyone on the internet can create, modify, or delete data in your database.",
+          evidence: `POST to Firestore documents endpoint returned 200`,
+          recommendation: "Immediately update Firestore Security Rules to block unauthenticated writes: `allow write: if request.auth != null;` \u2014 and review all existing data for tampering."
+        });
+      }
+    } catch {
+    }
+  } else {
+    errors.push(
+      "Could not determine Firebase project ID \u2014 skipping Firestore/RTDB probes. Provide --firebase-project-id or use a *.web.app / *.firebaseapp.com URL."
+    );
+  }
+  if (detectedProjectId) {
+    const rtdbUrls = [
+      `https://${detectedProjectId}-default-rtdb.firebaseio.com/.json?shallow=true`,
+      `https://${detectedProjectId}.firebaseio.com/.json?shallow=true`
+    ];
+    for (const rtdbUrl of rtdbUrls) {
+      try {
+        const rtdbRes = await fetchWithTimeout3(rtdbUrl);
+        if (rtdbRes.ok) {
+          rtdbPublicAccess = true;
+          let keyCount = 0;
+          try {
+            const body = await rtdbRes.json();
+            if (body && typeof body === "object") {
+              keyCount = Object.keys(body).length;
+            }
+          } catch {
+          }
+          findings.push({
+            id: "FB-002",
+            category: "firebase-rules-issue",
+            severity: "critical",
+            title: "Realtime Database allows unauthenticated read access",
+            description: 'The Firebase Realtime Database returned data at the root path without any authentication. RTDB rules are configured with `".read": true` or `".read": "auth == null"` or similar. All data stored in RTDB is publicly accessible.',
+            evidence: `GET ${rtdbUrl.replace(/\?.*/, "")} returned 200` + (keyCount > 0 ? ` (${keyCount} top-level keys)` : ""),
+            recommendation: 'Update RTDB Security Rules to require authentication: `".read": "auth != null"` at minimum. Review what data is stored in RTDB and assume it has been scraped if this rule was open.'
+          });
+          break;
+        }
+      } catch {
+        continue;
+      }
+    }
+    try {
+      const rtdbWriteUrl = `https://${detectedProjectId}-default-rtdb.firebaseio.com/vigile_probe_test.json`;
+      const rtdbWriteRes = await fetchWithTimeout3(rtdbWriteUrl, {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ _vigile_probe: "security_test" })
+      });
+      if (rtdbWriteRes.ok) {
+        rtdbPublicAccess = true;
+        findings.push({
+          id: "FB-002",
+          category: "firebase-rules-issue",
+          severity: "critical",
+          title: "Realtime Database allows unauthenticated WRITE access",
+          description: "Data was successfully written to Firebase Realtime Database without any authentication. Anyone can create, modify, or delete data.",
+          evidence: `PUT to RTDB vigile_probe_test.json returned 200`,
+          recommendation: 'Immediately update RTDB Security Rules: `".write": "auth != null"`. Audit all existing data for tampering. Consider migrating sensitive data to Firestore with stricter per-document rules.'
+        });
+      }
+    } catch {
+    }
+  }
+  if (detectedProjectId) {
+    const storageBucket = bundleConfig.storageBucket ?? `${detectedProjectId}.appspot.com`;
+    const storageUrl = `https://firebasestorage.googleapis.com/v0/b/${storageBucket}/o`;
+    try {
+      const storageRes = await fetchWithTimeout3(storageUrl);
+      if (storageRes.ok) {
+        let itemCount = 0;
+        try {
+          const body = await storageRes.json();
+          itemCount = body.items?.length ?? 0;
+        } catch {
+        }
+        findings.push({
+          id: "FB-004",
+          category: "firebase-rules-issue",
+          severity: "high",
+          title: "Firebase Storage bucket is publicly listable",
+          description: "The Firebase Storage bucket returned a file listing without authentication. Storage Security Rules allow public read access. All files in the bucket can be enumerated and downloaded by anyone.",
+          evidence: `GET ${storageUrl} returned 200` + (itemCount > 0 ? ` (${itemCount} files visible)` : ""),
+          recommendation: "Update Firebase Storage Security Rules to require authentication: `allow read: if request.auth != null;` \u2014 Review uploaded files for sensitive content (user uploads, profile pictures, documents)."
+        });
+      }
+    } catch {
+    }
+  }
+  try {
+    const headRes = await fetchWithTimeout3(baseUrl);
+    const headers = headRes.headers;
+    const missingHeaders = [];
+    if (!headers.get("x-content-type-options")) {
+      missingHeaders.push("X-Content-Type-Options");
+    }
+    if (!headers.get("x-frame-options") && !headers.get("content-security-policy")?.includes("frame-ancestors")) {
+      missingHeaders.push("X-Frame-Options or CSP frame-ancestors");
+    }
+    if (!headers.get("strict-transport-security")) {
+      missingHeaders.push("Strict-Transport-Security");
+    }
+    if (missingHeaders.length >= 2) {
+      findings.push({
+        id: "FB-005",
+        category: "cors-misconfiguration",
+        severity: "medium",
+        title: "Firebase Hosting missing security headers",
+        description: `The Firebase Hosting response is missing ${missingHeaders.length} recommended security headers: ${missingHeaders.join(", ")}. These headers protect against clickjacking, MIME sniffing, and protocol downgrade attacks.`,
+        evidence: `Missing: ${missingHeaders.join(", ")}`,
+        recommendation: 'Add security headers in firebase.json under hosting.headers: {"source": "**", "headers": [{"key": "X-Content-Type-Options", "value": "nosniff"}, {"key": "X-Frame-Options", "value": "DENY"}]}'
+      });
+    }
+  } catch {
+  }
+  return {
+    projectUrl: baseUrl,
+    projectId: detectedProjectId,
+    findings,
+    firestorePublicAccess,
+    rtdbPublicAccess,
+    configExposed,
+    reachable,
+    errors
+  };
+}
+
+// src/scanner/baas/cve-detector.ts
+var FETCH_TIMEOUT_MS4 = 15e3;
+var OSV_BATCH_URL = "https://api.osv.dev/v1/querybatch";
+var MAX_BATCH_SIZE = 100;
+async function fetchWithTimeout4(url, init) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS4);
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function extractCvssScore(vuln) {
+  if (vuln.severity && vuln.severity.length > 0) {
+    for (const sev of vuln.severity) {
+      const scoreMatch = sev.score.match(/CVSS:[^/]+\/.*?/);
+      if (scoreMatch && sev.type === "CVSS_V3") {
+        return estimateCvssFromVector(sev.score);
+      }
+    }
+  }
+  return 5;
+}
+function estimateCvssFromVector(vector) {
+  const v = vector.toUpperCase();
+  const avNetwork = v.includes("/AV:N");
+  const prNone = v.includes("/PR:N");
+  const cHigh = v.includes("/C:H");
+  const iHigh = v.includes("/I:H");
+  const aHigh = v.includes("/A:H");
+  const cLow = v.includes("/C:L");
+  const iLow = v.includes("/I:L");
+  const aLow = v.includes("/A:L");
+  let score = 5;
+  if (avNetwork) score += 1.5;
+  if (prNone) score += 1;
+  if (cHigh) score += 0.8;
+  if (iHigh) score += 0.8;
+  if (aHigh) score += 0.8;
+  if (cLow) score += 0.3;
+  if (iLow) score += 0.3;
+  if (aLow) score += 0.3;
+  return Math.min(10, Math.round(score * 10) / 10);
+}
+function extractPatchedVersion(vuln, pkgName) {
+  if (!vuln.affected) return null;
+  for (const affected of vuln.affected) {
+    if (affected.package.name !== pkgName) continue;
+    if (!affected.ranges) continue;
+    for (const range of affected.ranges) {
+      for (const event of range.events) {
+        if (event.fixed) return event.fixed;
+      }
+    }
+  }
+  return null;
+}
+function getPreferredId(vuln) {
+  if (vuln.aliases) {
+    const cve = vuln.aliases.find((a) => a.startsWith("CVE-"));
+    if (cve) return cve;
+  }
+  return vuln.id;
+}
+function cvssToSeverity(score) {
+  if (score >= 9) return "critical";
+  if (score >= 7) return "high";
+  if (score >= 4) return "medium";
+  return "low";
+}
+async function detectCves(packages) {
+  const matches = [];
+  const findings = [];
+  const errors = [];
+  if (packages.length === 0) {
+    return { packagesChecked: 0, matches, findings, errors };
+  }
+  const queryablePackages = packages.filter(
+    (p) => p.ecosystem !== "unknown" && p.version && !p.version.includes("*")
+  );
+  if (queryablePackages.length === 0) {
+    errors.push("No packages with valid version + ecosystem for CVE lookup");
+    return { packagesChecked: packages.length, matches, findings, errors };
+  }
+  const chunks = [];
+  for (let i = 0; i < queryablePackages.length; i += MAX_BATCH_SIZE) {
+    chunks.push(queryablePackages.slice(i, i + MAX_BATCH_SIZE));
+  }
+  for (const chunk of chunks) {
+    const queries = chunk.map((pkg) => ({
+      package: {
+        name: pkg.name,
+        ecosystem: pkg.ecosystem === "npm" ? "npm" : pkg.ecosystem === "pypi" ? "PyPI" : pkg.ecosystem
+      },
+      version: pkg.version
+    }));
+    try {
+      const res = await fetchWithTimeout4(OSV_BATCH_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ queries })
+      });
+      if (!res.ok) {
+        errors.push(`OSV.dev API returned HTTP ${res.status}`);
+        continue;
+      }
+      const body = await res.json();
+      for (let i = 0; i < body.results.length; i++) {
+        const result = body.results[i];
+        const pkg = chunk[i];
+        if (!result?.vulns || result.vulns.length === 0) continue;
+        const seenIds = /* @__PURE__ */ new Set();
+        for (const vuln of result.vulns) {
+          const vulnId = getPreferredId(vuln);
+          if (seenIds.has(vulnId)) continue;
+          seenIds.add(vulnId);
+          const cvssScore = extractCvssScore(vuln);
+          const patchedVersion = extractPatchedVersion(vuln, pkg.name);
+          const summary = vuln.summary ?? vuln.details?.slice(0, 200) ?? "No description available";
+          const match = {
+            pkg,
+            cveId: vulnId,
+            cvssScore,
+            summary,
+            patchedVersion
+          };
+          matches.push(match);
+          const severity = cvssToSeverity(cvssScore);
+          findings.push({
+            id: vulnId,
+            category: "cve-detected",
+            severity,
+            title: `${vulnId}: ${pkg.name}@${pkg.version}`,
+            description: `Known vulnerability in ${pkg.name} version ${pkg.version}. ${summary.slice(0, 300)}`,
+            evidence: `Package: ${pkg.name}@${pkg.version} (${pkg.ecosystem}) | CVSS: ${cvssScore} | ` + (patchedVersion ? `Fixed in: ${patchedVersion}` : "No patch available"),
+            recommendation: patchedVersion ? `Upgrade ${pkg.name} to version ${patchedVersion} or later. Run: npm install ${pkg.name}@${patchedVersion}` : `No patched version available. Consider removing or replacing ${pkg.name} with an alternative package. Monitor ${vulnId} for updates.`
+          });
+        }
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      errors.push(`OSV.dev query failed: ${msg}`);
+    }
+  }
+  return {
+    packagesChecked: packages.length,
+    matches,
+    findings,
+    errors
+  };
+}
+function parseNpmPackages(packageJsonText) {
+  try {
+    const parsed = JSON.parse(packageJsonText);
+    const deps = {
+      ...parsed.dependencies ?? {},
+      ...parsed.devDependencies ?? {}
+    };
+    return Object.entries(deps).map(([name, version]) => ({
+      name,
+      version: String(version).replace(/^[\^~>=<]+/, ""),
+      // strip semver range prefixes
+      ecosystem: "npm"
+    }));
+  } catch {
+    return [];
+  }
+}
+
+// src/scanner/baas/vibe-app-scanner.ts
+var FETCH_TIMEOUT_MS5 = 1e4;
+async function fetchWithTimeout5(url, init) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS5);
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function detectPlatform(findings, appUrl) {
+  for (const f of findings) {
+    const ev = (f.evidence ?? "").toLowerCase();
+    const title = f.title.toLowerCase();
+    if (ev.includes("supabase") || title.includes("supabase") || ev.includes("sb-") || ev.includes(".supabase.co")) {
+      return "supabase";
+    }
+    if (ev.includes("firebase") || title.includes("firebase") || ev.includes("aizasy") || // Firebase API key prefix (lowercased)
+    ev.includes(".firebaseapp.com") || ev.includes(".firebaseio.com")) {
+      return "firebase";
+    }
+  }
+  try {
+    const hostname = new URL(appUrl).hostname;
+    if (hostname.endsWith(".supabase.co")) return "supabase";
+    if (hostname.endsWith(".web.app") || hostname.endsWith(".firebaseapp.com")) {
+      return "firebase";
+    }
+  } catch {
+  }
+  return "unknown";
+}
+async function tryFetchPackageJson(appUrl) {
+  const baseUrl = appUrl.endsWith("/") ? appUrl : `${appUrl}/`;
+  const paths = [
+    "package.json",
+    "assets/package.json"
+  ];
+  for (const path of paths) {
+    try {
+      const res = await fetchWithTimeout5(`${baseUrl}${path}`);
+      if (res.ok) {
+        const text = await res.text();
+        if (text.trimStart().startsWith("{") && text.includes('"dependencies"')) {
+          return parseNpmPackages(text);
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  return [];
+}
+function extractPackagesFromBundleFindings(findings) {
+  const packageNames = /* @__PURE__ */ new Set();
+  for (const f of findings) {
+    const ev = f.evidence ?? "";
+    const nodeModuleMatches = ev.matchAll(/node_modules\/(@[^/]+\/[^/]+|[^/]+)/g);
+    for (const m of nodeModuleMatches) {
+      if (m[1]) packageNames.add(m[1]);
+    }
+  }
+  return Array.from(packageNames);
+}
+function deduplicateFindings3(findings) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const f of findings) {
+    const key = `${f.id}::${f.evidence ?? ""}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(f);
+  }
+  return unique;
+}
+async function scanVibeApp(opts) {
+  const allFindings = [];
+  const errors = [];
+  let packagesChecked = 0;
+  let cveMatches = 0;
+  const bundleResult = await analyzeBundles(opts.appUrl);
+  allFindings.push(...bundleResult.findings);
+  errors.push(...bundleResult.errors);
+  const detectedPlatform = opts.platform ?? detectPlatform(bundleResult.findings, opts.appUrl);
+  if (detectedPlatform === "supabase" || opts.supabaseUrl) {
+    const supabaseUrl = opts.supabaseUrl ?? opts.appUrl;
+    try {
+      const supabaseResult = await scanSupabase({ projectUrl: supabaseUrl });
+      allFindings.push(...supabaseResult.findings);
+      errors.push(...supabaseResult.errors);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      errors.push(`Supabase scan failed: ${msg}`);
+    }
+  }
+  if (detectedPlatform === "firebase" || opts.firebaseUrl) {
+    const firebaseUrl = opts.firebaseUrl ?? opts.appUrl;
+    try {
+      const firebaseResult = await scanFirebase({ projectUrl: firebaseUrl });
+      allFindings.push(...firebaseResult.findings);
+      errors.push(...firebaseResult.errors);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      errors.push(`Firebase scan failed: ${msg}`);
+    }
+  }
+  if (detectedPlatform === "unknown" && !opts.supabaseUrl && !opts.firebaseUrl) {
+    errors.push(
+      "Could not detect BaaS platform (Supabase or Firebase) from bundle analysis or URL. Provide --supabase <url> or --firebase <url> explicitly for deeper platform scanning."
+    );
+  }
+  let packages = [];
+  try {
+    packages = await tryFetchPackageJson(opts.appUrl);
+  } catch {
+  }
+  if (packages.length === 0) {
+    const bundlePackageNames = extractPackagesFromBundleFindings(bundleResult.findings);
+    if (bundlePackageNames.length > 0) {
+      errors.push(
+        `Detected ${bundlePackageNames.length} package(s) in bundles but could not determine versions for CVE lookup: ${bundlePackageNames.slice(0, 5).join(", ")}` + (bundlePackageNames.length > 5 ? "..." : "")
+      );
+    }
+  }
+  if (packages.length > 0) {
+    try {
+      const cveResult = await detectCves(packages);
+      allFindings.push(...cveResult.findings);
+      errors.push(...cveResult.errors);
+      packagesChecked = cveResult.packagesChecked;
+      cveMatches = cveResult.matches.length;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      errors.push(`CVE detection failed: ${msg}`);
+    }
+  }
+  const findings = deduplicateFindings3(allFindings);
+  return {
+    appUrl: opts.appUrl,
+    detectedPlatform,
+    findings,
+    bundlesAnalyzed: bundleResult.bundlesAnalyzed,
+    packagesChecked,
+    cveMatches,
+    errors
+  };
+}
+
 // src/index.ts
 var VERSION = require_package().version;
 var program = new import_commander.Command();
@@ -2695,7 +5024,7 @@ function addScanOptions(cmd) {
   return cmd.option("-j, --json", "Output results as JSON").option("-v, --verbose", "Show detailed findings and score breakdown").option("-c, --config <path>", "Path to a custom MCP config file").option("-o, --output <path>", "Write results to a file").option(
     "--client <client>",
     "Only scan a specific client (claude-desktop, cursor, claude-code, windsurf, vscode, openclaw)"
-  ).option("-s, --skills", "Scan agent skills only (SKILL.md, .mdc rules, CLAUDE.md, etc.)").option("-a, --all", "Scan both MCP servers and agent skills").option("--sentinel", "Enable Sentinel runtime monitoring (Pro+ feature)").option("--sentinel-server <name>", "Monitor a specific MCP server by name").option("--sentinel-duration <seconds>", "Monitoring duration in seconds (default: 120)", parseInt).option("--no-upload", "Skip uploading scan results to Vigile API");
+  ).option("-s, --skills", "Scan agent skills only (SKILL.md, .mdc rules, CLAUDE.md, etc.)").option("-a, --all", "Scan both MCP servers and agent skills").option("--sentinel", "Enable Sentinel runtime monitoring (Pro+ feature)").option("--sentinel-server <name>", "Monitor a specific MCP server by name").option("--sentinel-duration <seconds>", "Monitoring duration in seconds (default: 120)", parseInt).option("--no-upload", "Skip uploading scan results to Vigile API").option("--supabase <url>", "Scan a Supabase project URL for RLS issues and exposed keys").option("--supabase-key <key>", "Supabase anon key (auto-detected from bundles if omitted)").option("--firebase <url>", "Scan a Firebase project URL for rules issues and exposed keys").option("--app <url>", "Scan a deployed web app for exposed secrets and BaaS misconfigs");
 }
 addScanOptions(
   program.command("scan").description("Scan MCP server configurations and agent skill files on this machine")
@@ -2866,6 +5195,9 @@ async function runScan(options) {
   if (options.sentinel) {
     await runSentinel(options, results, isJSON);
   }
+  if (options.supabase || options.firebase || options.app) {
+    await runBaaSScan(options, isJSON);
+  }
   if (summary.bySeverity.critical > 0 || summary.bySeverity.high > 0) {
     await new Promise((resolve) => {
       if (process.stdout.writableNeedDrain) {
@@ -2926,6 +5258,90 @@ async function uploadResults(mcpResults, skillResults, isJSON) {
     printUploadSuccess(summary);
   }
 }
+async function runBaaSScan(options, isJSON) {
+  const spinner = isJSON ? null : (0, import_ora.default)("Running BaaS security scan...").start();
+  let totalFindings = 0;
+  let criticalOrHigh = 0;
+  if (options.supabase) {
+    const result = await scanSupabase({
+      projectUrl: options.supabase,
+      anonKey: options.supabaseKey
+    });
+    totalFindings += result.findings.length;
+    criticalOrHigh += result.findings.filter(
+      (f) => f.severity === "critical" || f.severity === "high"
+    ).length;
+    if (!isJSON) {
+      spinner?.stop();
+      console.log(import_chalk2.default.bold(`
+  Supabase: ${options.supabase}`));
+      if (result.errors.length > 0) {
+        result.errors.forEach((e) => console.log(import_chalk2.default.yellow(`  \u26A0  ${e}`)));
+      }
+      result.findings.forEach((f) => {
+        const color = f.severity === "critical" ? import_chalk2.default.red : f.severity === "high" ? import_chalk2.default.yellow : import_chalk2.default.gray;
+        console.log(color(`  [${f.severity.toUpperCase()}] ${f.title}`));
+        if (options.verbose) console.log(import_chalk2.default.gray(`    ${f.description}`));
+      });
+    }
+  }
+  if (options.firebase) {
+    const result = await scanFirebase({ projectUrl: options.firebase });
+    totalFindings += result.findings.length;
+    criticalOrHigh += result.findings.filter(
+      (f) => f.severity === "critical" || f.severity === "high"
+    ).length;
+    if (!isJSON) {
+      spinner?.stop();
+      console.log(import_chalk2.default.bold(`
+  Firebase: ${options.firebase}`));
+      if (result.errors.length > 0) {
+        result.errors.forEach((e) => console.log(import_chalk2.default.yellow(`  \u26A0  ${e}`)));
+      }
+      result.findings.forEach((f) => {
+        const color = f.severity === "critical" ? import_chalk2.default.red : f.severity === "high" ? import_chalk2.default.yellow : import_chalk2.default.gray;
+        console.log(color(`  [${f.severity.toUpperCase()}] ${f.title}`));
+        if (options.verbose) console.log(import_chalk2.default.gray(`    ${f.description}`));
+      });
+    }
+  }
+  if (options.app) {
+    const result = await scanVibeApp({ appUrl: options.app });
+    totalFindings += result.findings.length;
+    criticalOrHigh += result.findings.filter(
+      (f) => f.severity === "critical" || f.severity === "high"
+    ).length;
+    if (!isJSON) {
+      spinner?.stop();
+      console.log(import_chalk2.default.bold(`
+  App: ${options.app}`));
+      console.log(import_chalk2.default.gray(`  Platform detected: ${result.detectedPlatform}`));
+      console.log(import_chalk2.default.gray(`  Bundles analyzed: ${result.bundlesAnalyzed}`));
+      if (result.errors.length > 0) {
+        result.errors.forEach((e) => console.log(import_chalk2.default.yellow(`  \u26A0  ${e}`)));
+      }
+      result.findings.forEach((f) => {
+        const color = f.severity === "critical" ? import_chalk2.default.red : f.severity === "high" ? import_chalk2.default.yellow : import_chalk2.default.gray;
+        console.log(color(`  [${f.severity.toUpperCase()}] ${f.title}`));
+        if (options.verbose) {
+          console.log(import_chalk2.default.gray(`    ${f.description}`));
+          if (f.evidence) console.log(import_chalk2.default.gray(`    Evidence: ${f.evidence}`));
+        }
+      });
+    }
+  }
+  if (!isJSON) {
+    console.log("");
+    if (totalFindings === 0) {
+      console.log(import_chalk2.default.green("  BaaS scan complete \u2014 no secrets or misconfigurations found"));
+    } else {
+      console.log(
+        import_chalk2.default.yellow(`  BaaS scan complete \u2014 ${totalFindings} finding(s), ${criticalOrHigh} critical/high`)
+      );
+    }
+    console.log("");
+  }
+}
 function mapMCPResultToApiPayload(result) {
   let packageUrl;
   if (result.server.command === "npx") {