checkmyvibe 1.2.0 → 1.3.0

package/install.js

@@ -10,6 +10,7 @@ const srcSkill = path.join(__dirname, 'SKILL.md');
 const srcScripts = path.join(__dirname, 'scripts');
 const srcReferences = path.join(__dirname, 'references');
 const srcCommands = path.join(__dirname, 'commands');
+const srcAdapters = path.join(__dirname, 'adapters');
 
 // Destination selection
 const cwd = process.cwd();
@@ -32,6 +33,48 @@ function copyRecursiveSync(src, dest) {
   }
 }
 
+function installHarnessAdapters() {
+  const installed = [];
+
+  try {
+    // Cursor rule -> .cursor/rules/
+    const cursorRulesDir = path.join(cwd, '.cursor', 'rules');
+    const mdcSrc = path.join(srcAdapters, 'checkmyvibe.mdc');
+    if (fs.existsSync(path.join(cwd, '.cursor')) && fs.existsSync(mdcSrc)) {
+      fs.mkdirSync(cursorRulesDir, { recursive: true });
+      fs.copyFileSync(mdcSrc, path.join(cursorRulesDir, 'checkmyvibe.mdc'));
+      installed.push(`Cursor rule        -> ${path.relative(cwd, path.join(cursorRulesDir, 'checkmyvibe.mdc'))}`);
+    }
+
+    // opencode command -> .opencode/command/
+    const opencodeCmdDir = path.join(cwd, '.opencode', 'command');
+    const ocSrc = path.join(srcAdapters, 'opencode-checkmyvibe.md');
+    if (fs.existsSync(path.join(cwd, '.opencode')) && fs.existsSync(ocSrc)) {
+      fs.mkdirSync(opencodeCmdDir, { recursive: true });
+      fs.copyFileSync(ocSrc, path.join(opencodeCmdDir, 'checkmyvibe.md'));
+      installed.push(`opencode command   -> ${path.relative(cwd, path.join(opencodeCmdDir, 'checkmyvibe.md'))}`);
+    }
+
+    // AGENTS.md -> append discovery snippet if not already present
+    const agentsPath = path.join(cwd, 'AGENTS.md');
+    const snippetSrc = path.join(srcAdapters, 'AGENTS-SNIPPET.md');
+    if (fs.existsSync(agentsPath) && fs.existsSync(snippetSrc)) {
+      let agentsContent = fs.readFileSync(agentsPath, 'utf8');
+      if (!agentsContent.includes('## checkmyvibe')) {
+        const snippet = fs.readFileSync(snippetSrc, 'utf8');
+        const snippetBody = snippet.split(/^---$/m).pop().trim();
+        agentsContent = agentsContent.trimEnd() + '\n\n' + snippetBody + '\n';
+        fs.writeFileSync(agentsPath, agentsContent);
+        installed.push('AGENTS.md          -> appended checkmyvibe section');
+      }
+    }
+  } catch (err) {
+    console.log(`  (adapter installation skipped: ${err.message})`);
+  }
+
+  return installed;
+}
+
 function performInstall(skillDest, commandsDest) {
   try {
     console.log(`\nInstalling checkmyvibe skill to: ${skillDest}...`);
@@ -67,6 +110,14 @@ function performInstall(skillDest, commandsDest) {
       });
     }
 
+    // Copy adapters into the skill folder so they ship with the skill itself
+    if (fs.existsSync(srcAdapters)) {
+      copyRecursiveSync(srcAdapters, path.join(skillDest, 'adapters'));
+    }
+
+    // Detect other agent harnesses in this project and install their adapters
+    const adapters = installHarnessAdapters();
+
     console.log('\n=========================================');
     console.log('🎉 checkmyvibe Agent Skill & Commands installed!');
     console.log('=========================================');
@@ -80,6 +131,13 @@ function performInstall(skillDest, commandsDest) {
     console.log('  /checkmyvibe backend   (or /checkmyvibe-backend)   -> Server-side (auth, db, IDOR, input, payment)');
     console.log('  /checkmyvibe frontend  (or /checkmyvibe-frontend)  -> Client-side (bundle leaks, client auth, pricing)');
     console.log('  /checkmyvibe payment   (or /checkmyvibe-payment)   -> Payment & pricing integrity');
+    console.log('=========================================');
+    if (adapters.length > 0) {
+      console.log('\nOther agent harnesses detected — adapters installed:');
+      adapters.forEach((line) => console.log(`  ${line}`));
+    }
+    console.log('\nUsing Codex, Gemini CLI, Cursor, or another AGENTS.md-based agent?');
+    console.log(`Paste the snippet from ${path.join(skillDest, 'adapters', 'AGENTS-SNIPPET.md')} into your AGENTS.md.`);
     console.log('=========================================\n');
   } catch (err) {
     console.error('Error installing skill:', err.message);

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "checkmyvibe",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "A structured production readiness and code quality workflow Agent Skill for AI coding assistants to catch common vibe-coded configuration issues.",
   "main": "install.js",
   "bin": {
@@ -12,6 +12,7 @@
     "commands/",
     "scripts/",
     "references/",
+    "adapters/",
     "install.js",
     "README.md",
     "LICENSE"

package/references/vibe_risk_patterns.md

@@ -1,81 +1,125 @@
 # Vibe Readiness Risk Patterns
 
-This document serves as a reference for common readiness risk patterns identified in AI-generated ("vibe-coded") applications. AI coding assistants frequently introduce these configuration and design flaws because they prioritize speed, feature completion, and standalone component demonstration over robust production-ready setups.
+This document serves as an exhaustive reference for common readiness risk patterns identified in AI-generated ("vibe-coded") applications. AI coding assistants frequently introduce these configuration and design flaws because they prioritize speed, feature completion, and standalone component demonstration over robust production-ready setups.
 
 ---
 
 ## 1. Exposed Secrets
 
 ### Overview
-AI assistants often scaffold code with hardcoded API keys, JWT secrets, database connection strings, or third-party client keys directly inside configuration files or source code. Additionally, local environment files (`.env`) are frequently created without updating the project's `.gitignore` to prevent them from being committed to version control.
+AI assistants scaffold code with hardcoded API keys, JWT secrets, database connection strings, or third-party client keys directly inside configuration files or source code. Local environment files (`.env`) are frequently created without updating `.gitignore` or `.dockerignore`.
 
 ### Why it happens in AI-generated code
-[Placeholder: The user will fill in real-world examples and analysis of why this happens in AI-generated code.]
+1. **Context-Window Convenience:** Models frequently inline secret strings (`const openai = new OpenAI({ apiKey: "sk-proj-..." })`) so code runs immediately without requiring manual `.env` file configuration by the user.
+2. **Bundler Prefix Confusion:** AI models mix up server and client environments in Next.js/Vite, assigning server-only secrets to `NEXT_PUBLIC_*` or `VITE_*` variables.
+3. **React Server Component (RSC) Prop Leaks:** In Next.js App Router, an AI generates a Server Component that imports an environment variable and passes it as a prop to a client component (`<ChatWidget apiKey={process.env.OPENAI_KEY} />`), serializing the private secret directly into the browser HTML.
+4. **Docker Leaks:** Models create a `Dockerfile` with `COPY . .` but omit `.dockerignore`, baking local `.env` files into public container images.
 
 ### The Correct Fix
-[Placeholder: The user will fill in the correct fix and mitigation strategies.]
+- Keep all secrets in server-side environment variables accessed strictly on the server: `process.env.OPENAI_API_KEY`.
+- Ensure `.env*` is listed in both `.gitignore` and `.dockerignore`.
+- Check git commit history (`git log --all --full-history -- .env`) and rotate any key that was ever committed.
 
 ---
 
 ## 2. Missing/Fake Authentication (Fake/Stubbed Auth)
 
 ### Overview
-When generating authentication flows, AI tools often implement mock authentication functions, fake login buttons, or bypass logic (e.g. returning `true` or dummy user objects unconditionally) to make testing quick. Developers may unknowingly deploy this placeholder logic directly to production, leaving endpoints unprotected.
+When generating authentication flows, AI tools often implement mock authentication functions, dummy user objects, or bypass middleware to make manual testing seamless during development. Developers unknowingly deploy this placeholder logic directly to production.
 
 ### Why it happens in AI-generated code
-[Placeholder: The user will fill in real-world examples and analysis of why this happens in AI-generated code.]
+1. **Scaffolding Shortcuts:** AI assistants generate middleware like:
+   ```js
+   function authMiddleware(req, res, next) {
+     req.user = { id: "test-user", role: "admin" }; // TODO: replace with real JWT auth
+     next();
+   }
+   ```
+2. **Provider Route Matcher Gaps:** When integrating modern auth providers like Clerk or NextAuth, AI tools often write overly permissive route matchers in Next.js `middleware.ts` (e.g., omitting `/api/(.*)`), leaving backend routes unprotected.
+3. **Supabase Server Session Trap:** Models frequently call `supabase.auth.getSession()` on server routes or Server Actions. Supabase warns that `getSession()` is insecure on the server because it does not cryptographically revalidate the token with the Supabase Auth server.
 
 ### The Correct Fix
-[Placeholder: The user will fill in the correct fix and mitigation strategies.]
+- Eliminate all mock auth stubs from production code paths.
+- On Supabase servers, always use `await supabase.auth.getUser()`.
+- For Clerk, protect all sensitive API routes with `auth.protect()`.
+- Store authentication tokens in `httpOnly`, `Secure`, `SameSite` cookies rather than browser `localStorage`.
 
 ---
 
 ## 3. Database Misconfiguration (Permissive Database Rules / RLS)
 
 ### Overview
-Services like Supabase or Firebase Firestore rely on Row-Level Security (RLS) or security rules files to protect data access. AI assistants frequently scaffold projects with default allow-all rules (e.g. `allow read, write: if true;` or `CREATE POLICY ... TO public USING (true);`) or create tables in Supabase without enabling RLS, enabling any client with an anonymous key to query or modify all records.
+Databases directly exposed to the browser (Supabase, Firebase, Convex) rely on Row-Level Security (RLS) or security rules to restrict data access. AI assistants frequently scaffold projects with default allow-all rules (`USING (true)` / `allow read, write: if true;`) or create tables without enabling RLS.
 
 ### Why it happens in AI-generated code
-[Placeholder: The user will fill in real-world examples and analysis of why this happens in AI-generated code.]
+1. **Quick-Fixing Permission Errors:** When an AI model encounters permission errors while building a frontend prototype, its default reaction is often to run `CREATE POLICY "allow_all" ON <table> FOR ALL USING (true);`.
+2. **Server-Backed ORM Confusion:** When transitioning between Supabase and server-backed ORMs (Prisma, Drizzle, Neon, local SQLite/Postgres), models often fail to recognize whether the database is private behind a server or public to the browser.
+3. **Exposed SQLite Files:** In lightweight stacks, models place `data.sqlite` directly inside the `public/` directory, allowing any web visitor to download the entire database via a simple HTTP GET request.
+4. **NoSQL Query Injection:** In MongoDB/Mongoose backends, models pass `req.body` directly to `User.findOne(req.body)`, allowing query selectors like `{ "$gt": "" }` to bypass password checks.
 
 ### The Correct Fix
-[Placeholder: The user will fill in the correct fix and mitigation strategies.]
+- In Supabase, enable RLS on every table and bind policies to `auth.uid() = user_id`.
+- Never place SQLite or database files in public web directories.
+- In serverless Postgres (Neon), configure connection pooling (`@neondatabase/serverless`) to prevent connection pool exhaustion.
+- Sanitize Mongoose inputs using schema validation or explicit field extraction instead of passing raw request objects.
 
 ---
 
 ## 4. Broken Object-Level Authorization (BOLA / IDOR)
 
 ### Overview
-Broken Object-Level Authorization occurs when an application exposes a resource endpoint (e.g. `/api/orders/:id` or fetching data by a user-supplied ID parameter) and retrieves or updates the resource without verifying that the authenticated user owns or has permission to access that specific resource.
+BOLA/IDOR occurs when an endpoint retrieves, modifies, or deletes a resource based on a client-supplied identifier (e.g. `/api/orders/:id`, Server Actions `deleteDocument(id)`) without verifying that the authenticated user owns or has permission to access that resource.
 
 ### Why it happens in AI-generated code
-[Placeholder: The user will fill in real-world examples and analysis of why this happens in AI-generated code.]
+1. **Single-Table Query Scaffolding:** AI tools generate queries using only the primary key:
+   ```js
+   const item = await db.query('SELECT * FROM items WHERE id = $1', [req.params.id]);
+   ```
+2. **Server Actions RPC Insecurity:** In Next.js App Router, models expose Server Actions (`'use server'`) without re-authenticating the session inside the action function body.
+3. **Multi-Tenant Blindness:** In team/organization applications, models verify `WHERE organization_id = req.params.orgId` without checking whether the requesting user is actually a member of that organization.
 
 ### The Correct Fix
-[Placeholder: The user will fill in the correct fix and mitigation strategies.]
+- Always scope database queries by both resource ID and the authenticated user/organization ID:
+  ```js
+  const order = await db.query(
+    'SELECT * FROM orders WHERE id = $1 AND user_id = $2',
+    [req.params.id, req.user.id]
+  );
+  if (!order) return res.status(404).json({ error: 'Not found' });
+  ```
 
 ---
 
-## 5. Unvalidated Inputs
+## 5. Unvalidated Inputs, SSRF, & DOM XSS
 
 ### Overview
-AI code often lacks backend input validation, trusting that client-side forms are sufficient. This opens the door to SQL injection, Cross-Site Scripting (XSS), server-side crashes due to unexpected data formats, or logic bypasses.
+AI-generated code frequently trusts client inputs, leading to Server-Side Request Forgery (SSRF), DOM XSS in AI markdown renderers, SQL/NoSQL injection, and mass assignment.
 
 ### Why it happens in AI-generated code
-[Placeholder: The user will fill in real-world examples and analysis of why this happens in AI-generated code.]
+1. **SSRF in AI Link/Image Scrapers:** AI apps frequently take a user-supplied URL to scrape or summarize (e.g. `axios.get(req.body.url)`). Attackers pass `http://169.254.169.254/latest/meta-data/` to steal cloud metadata and IAM credentials.
+2. **DOM XSS via AI Markdown:** AI chat interfaces render model responses using `dangerouslySetInnerHTML` or `react-markdown` without `rehype-sanitize` or DOMPurify, enabling persistent XSS attacks via prompt injection.
+3. **Mass Assignment:** Models write `await prisma.user.update({ where: { id }, data: req.body })`, allowing callers to overwrite privileged fields like `role: "admin"` or `isVerified: true`.
 
 ### The Correct Fix
-[Placeholder: The user will fill in the correct fix and mitigation strategies.]
+- Filter user-supplied URLs against private IP ranges (`127.0.0.1`, `169.254.169.254`, `10.*.*.*`) before executing server-side HTTP requests.
+- Sanitize rendered markdown using `rehype-sanitize` or DOMPurify.
+- Whitelist request body fields explicitly when updating database records.
 
 ---
 
-## 6. Client-Side Payment Logic
+## 6. Client-Side Payment Logic & Webhook Risks
 
 ### Overview
-AI tools often write payment flows where pricing calculations, transaction amounts, subscription statuses, or checkout processes are determined or validated entirely on the client side. Attackers can easily intercept and modify request bodies (e.g. setting a premium product price to `$0.00`) before sending it to a payment gateway API.
+AI assistants frequently write payment flows where prices are trusted from client payloads, webhook signatures are never verified, idempotency is ignored, and subscription cancellations are unhandled.
 
 ### Why it happens in AI-generated code
-[Placeholder: The user will fill in real-world examples and analysis of why this happens in AI-generated code.]
+1. **Trusting Client Amounts:** When creating checkout sessions, models extract `price` from `req.body` (`const { price } = req.body; charge(price);`), allowing users to edit the price to $0.01 in browser dev tools.
+2. **Omitted Webhook Signatures:** In Stripe, Lemon Squeezy, Dodo Payments, or Razorpay integrations, models read webhook events directly from `req.body` without verifying cryptographic signatures.
+3. **Lack of Idempotency:** Gateways retry webhooks on timeouts. Without tracking `event.id` in the database, retried webhooks grant duplicate credits or double-ship orders.
+4. **The Cancellation Trap:** Models implement `checkout.session.completed` to grant access, but completely forget to listen for `customer.subscription.deleted` or `subscription_cancelled`. Canceled users retain paid access indefinitely.
 
 ### The Correct Fix
-[Placeholder: The user will fill in the correct fix and mitigation strategies.]
+- Always resolve prices server-side from your product catalog or database.
+- Cryptographically verify webhook signatures using gateway SDKs or HMAC SHA-256 before acting on event payloads.
+- Record processed webhook event IDs (`event.id`) to ensure idempotent execution.
+- Implement subscription cancellation and payment failure listeners to revoke access when plans expire.

package/scripts/check_auth_patterns.py

@@ -4,6 +4,10 @@ import sys
 import re
 import fnmatch
 
+# Ensure stdout supports UTF-8 on Windows
+if hasattr(sys.stdout, 'reconfigure'):
+    sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+
 SKIP_DIRS = {
     'node_modules', '.git', 'build', 'dist', '.next', '.svelte-kit', 
     '__pycache__', 'venv', '.venv', 'env', 'coverage', 'out',
@@ -23,7 +27,8 @@ SKIP_EXTS = {
     '.gz', '.mp3', '.mp4', '.mov', '.db', '.sqlite', '.exe', '.dll',
     '.so', '.dylib', '.woff', '.woff2', '.ttf', '.eot', '.lock',
     '.package-lock.json', '.pnpm-lock.yaml', '.yarn.lock', '.map',
-    '.svg', '.css', '.scss', '.less', '.html', '.xml'
+    '.svg', '.css', '.scss', '.less', '.html', '.xml',
+    '.md', '.markdown', '.txt', '.rst'
 }
 
 # 1. Naming patterns for fake/mock/bypass authentication
@@ -50,7 +55,23 @@ STUB_PATTERNS = [
      
     # Generic bypass function or property: e.g. "authBypass: true", "skipAuth: true"
     (re.compile(r'(?i)\b(?:authBypass|skipAuth|disableAuth|bypassAuthentication|devAuth)\b\s*:\s*true\b'),
-     "Authentication bypass flag set to true")
+     "Authentication bypass flag set to true"),
+     
+    # Hardcoded mock user object return in auth-related functions
+    (re.compile(r'(?i)(?:function\s+\w*(?:auth|login|user|session|account)\w*\s*\([^)]*\)|\b\w*(?:auth|login|user|session|account)\w*\s*=\s*(?:async\s*)?\([^)]*\)\s*=>)\s*(?:\{[^}]*return\s*\{|\(\s*\{)\s*[\'"`]?(?:id|user_id|userId|role|email)[\'"`]?\s*:'),
+     "Hardcoded mock user object returned from auth handler"),
+
+    # Middleware unconditionally calling next() without checks
+    (re.compile(r'(?i)(?:\b\w*(?:auth|protect|guard|requireUser|session)\w*\s*=\s*(?:async\s*)?\([^)]*next[^)]*\)\s*=>|function\s+\w*(?:auth|protect|guard|requireUser|session)\w*\s*\([^)]*next[^)]*\))\s*\{?\s*next\(\);?\s*\}?'),
+     "Auth middleware unconditionally calls next() with no validation"),
+
+    # Direct assignment of hardcoded req.user
+    (re.compile(r'(?i)req\.user\s*=\s*\{\s*[\'"`]?(?:id|user_id|userId|role)[\'"`]?\s*:\s*[\'"`]'),
+     "Hardcoded mock user assigned directly to req.user"),
+
+    # Supabase insecure getSession() on server
+    (re.compile(r'(?i)\bsupabase\.auth\.getSession\(\)'),
+     "Insecure supabase.auth.getSession() used (use supabase.auth.getUser() on the server to verify JWT authenticity)"),
 ]
 
 def is_binary(file_path):
@@ -107,6 +128,10 @@ def main():
         dirs[:] = [d for d in dirs if d not in SKIP_DIRS and not d.startswith('.')]
         
         for file in files:
+            if file in ['check_auth_patterns.py', 'scan_secrets.py', 'check_db_config.py', 'check_gitignore.py', 'check_payment_config.py']:
+                continue
+            if 'checkmyvibe-report' in file.lower():
+                continue
             ext = os.path.splitext(file)[1].lower()
             if ext in SKIP_EXTS or is_test_file(file) or file.startswith('.'):
                 continue

package/scripts/check_db_config.py

@@ -4,10 +4,14 @@ import sys
 import re
 import fnmatch
 
+# Ensure stdout supports UTF-8 on Windows
+if hasattr(sys.stdout, 'reconfigure'):
+    sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+
 SKIP_DIRS = {
-    'node_modules', '.git', 'dist', 'build',
+    'node_modules', '.git', 'dist', 'build', '.next', '.svelte-kit',
     '__tests__', '__mocks__', 'tests', 'test', 'spec', 'fixtures',
-    'mocks', 'e2e', 'cypress'
+    'mocks', 'e2e', 'cypress', 'venv', '.venv'
 }
 
 TEST_FILE_PATTERNS = ['*.test.*', '*.spec.*', '*.mock.*']
@@ -21,9 +25,11 @@ FIREBASE_PERMISSIVE = re.compile(r'allow\s+[\w\s,]+:\s*if\s+true\s*;')
 # Permissive Realtime Database rules
 RTDB_PERMISSIVE = re.compile(r'"\.(read|write)"\s*:\s*"true"')
 
-# Permissive policies in Supabase / SQL schema definition
-SUPABASE_PERMISSIVE_POLICY = re.compile(r'(?i)create\s+policy\s+\w+\s+on\s+\w+\s+(?:for\s+\w+\s+)?to\s+(?:public|anon)\s+using\s*\(\s*true\s*\)')
-SUPABASE_PERMISSIVE_POLICY_SIMPLE = re.compile(r'(?i)using\s*\(\s*true\s*\)|with\s+check\s*\(\s*true\s*\)')
+# Insecure DB connection configuration
+INSECURE_DB_SSL = re.compile(r'(?i)(?:sslmode\s*=\s*disable|ssl\s*:\s*false|rejectUnauthorized\s*:\s*false)')
+
+# NoSQL / MongoDB direct body injection
+MONGO_INJECTION_PATTERN = re.compile(r'(?i)\b\w+\.(?:find|findOne|deleteMany|updateOne|updateMany)\s*\(\s*(?:req\.body|req\.query)\s*\)')
 
 def scan_firebase_rules(file_path):
     """Scan Firestore/Storage rules for allow-all statements."""
@@ -58,18 +64,14 @@ def scan_sql_rls(file_path):
         with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
             content = f.read()
             
-        # 1. Strip comments to avoid false matches (e.g. commented-out commands or code annotations)
-        # Strip single-line -- comments
+        # 1. Strip comments
         content_no_comments = re.sub(r'--.*$', '', content, flags=re.M)
-        # Strip multiline /* */ comments
         content_no_comments = re.sub(r'/\*.*?\*/', '', content_no_comments, flags=re.S)
 
-        # 2. Find all CREATE TABLE statements (support schemas, quotes, etc.)
+        # 2. Find all CREATE TABLE statements
         created_tables = re.findall(r'(?i)create\s+table\s+(?:if\s+not\s+exists\s+)?([\w\.]+)', content_no_comments)
-        # Find all ENABLE ROW LEVEL SECURITY statements
         enabled_rls = re.findall(r'(?i)alter\s+table\s+(?:if\s+exists\s+)?([\w\.]+)\s+enable\s+row\s+level\s+security', content_no_comments)
         
-        # Clean table names (strip quotes, normalize schemas)
         def clean_table_name(t):
             t = t.replace('"', '').replace("'", "")
             if '.' in t:
@@ -82,15 +84,12 @@ def scan_sql_rls(file_path):
         for idx, table in enumerate(created_tables):
             clean_t = clean_table_name(table)
             if clean_t not in enabled_clean:
-                # Find line number in original file
                 escaped_t = re.escape(table)
                 match = re.search(r'(?i)create\s+table\s+(?:if\s+not\s+exists\s+)?' + escaped_t, content)
                 line_num = content.count('\n', 0, match.start()) + 1 if match else 1
                 findings.append((line_num, f"Table '{table}' is created but Row Level Security (RLS) is not enabled"))
                 
-        # 3. Find permissive policies:
-        # Search for CREATE POLICY ... USING (true) or WITH CHECK (true)
-        # Handles multiline policy definitions and quoted policy names
+        # 3. Find permissive policies
         policy_pattern = re.compile(
             r'(?i)create\s+policy\s+("[^"]+"|[a-zA-Z_]\w*)\s+on\s+([\w\.]+)\s+[^;]+?(?:using|with\s+check)\s*\(\s*true\s*\)',
             re.DOTALL
@@ -99,20 +98,41 @@ def scan_sql_rls(file_path):
         for match in policy_pattern.finditer(content_no_comments):
             policy_name = match.group(1)
             table_name = match.group(2)
-            # Find the character position of this policy match in the original content
             orig_match = re.search(r'(?i)create\s+policy\s+' + re.escape(policy_name), content)
             line_num = content.count('\n', 0, orig_match.start()) + 1 if orig_match else 1
-            findings.append((line_num, f"Permissive policy {policy_name} on table {table_name} allows public read/write via USING(true) / CHECK(true)"))
+            findings.append((line_num, f"Permissive policy {policy_name} on table {table_name} allows public access via USING(true) / CHECK(true)"))
             
     except Exception:
         pass
     return findings
 
+def detect_project_db_context(target_dir):
+    """Detect if project uses client-facing BaaS (Supabase/Firebase) or server-only ORM (Prisma/Drizzle/Mongoose/Neon)."""
+    has_supabase = False
+    has_firebase = False
+    has_server_orm = False
+    
+    for root, dirs, files in os.walk(target_dir):
+        dirs[:] = [d for d in dirs if d not in SKIP_DIRS and not d.startswith('.')]
+        if 'supabase' in root.lower() or any('supabase' in f.lower() for f in files):
+            has_supabase = True
+        if any(f in ['firestore.rules', 'firebase.json', 'database.rules.json'] for f in files):
+            has_firebase = True
+        if 'schema.prisma' in files or any(f.startswith('drizzle.config') for f in files):
+            has_server_orm = True
+            
+    return {
+        'has_supabase': has_supabase,
+        'has_firebase': has_firebase,
+        'has_server_orm': has_server_orm
+    }
+
 def main():
     target_dir = sys.argv[1] if len(sys.argv) > 1 else '.'
     target_dir = os.path.abspath(target_dir)
     
     findings_by_file = {}
+    context = detect_project_db_context(target_dir)
     
     for root, dirs, files in os.walk(target_dir):
         dirs[:] = [d for d in dirs if d not in SKIP_DIRS and not d.startswith('.')]
@@ -123,23 +143,52 @@ def main():
             file_path = os.path.join(root, file)
             rel_path = os.path.relpath(file_path, target_dir)
             
-            # Check for Firebase Firestore/Storage rules
+            # 1. Check for exposed SQLite files in public web directories
+            if any(file.lower().endswith(ext) for ext in ['.sqlite', '.sqlite3', '.db']):
+                rel_lower = rel_path.lower().replace('\\', '/')
+                if any(pub in rel_lower for pub in ['public/', 'static/', 'www/', 'dist/', 'assets/']):
+                    findings_by_file.setdefault(rel_path, []).append(
+                        (1, f"Exposed SQLite database file '{file}' in public directory (Critical: allows arbitrary database download)")
+                    )
+            
+            # 2. Check for Firebase Firestore/Storage rules
             if file in ['firestore.rules', 'storage.rules']:
                 file_findings = scan_firebase_rules(file_path)
                 if file_findings:
                     findings_by_file[rel_path] = file_findings
                     
-            # Check for Firebase Realtime Database rules
+            # 3. Check for Firebase Realtime Database rules
             elif file == 'database.rules.json':
                 file_findings = scan_rtdb_rules(file_path)
                 if file_findings:
                     findings_by_file[rel_path] = file_findings
                     
-            # Check for SQL migrations/schema files
+            # 4. Check for SQL migrations/schema files
             elif file.endswith('.sql'):
-                file_findings = scan_sql_rls(file_path)
-                if file_findings:
-                    findings_by_file[rel_path] = file_findings
+                # In server-only ORM stacks (Prisma/Drizzle/Neon) without Supabase, suppress RLS missing warnings on standard migration tables
+                is_supabase_migration = 'supabase' in rel_path.lower()
+                if is_supabase_migration or context['has_supabase'] or not context['has_server_orm']:
+                    file_findings = scan_sql_rls(file_path)
+                    if file_findings:
+                        findings_by_file[rel_path] = file_findings
+
+            # 5. Check JS/TS/Py files for NoSQL injection and insecure SSL configs
+            elif any(file.endswith(ext) for ext in ['.js', '.ts', '.jsx', '.tsx', '.py']):
+                if file in ['check_db_config.py', 'scan_secrets.py', 'check_auth_patterns.py', 'check_payment_config.py']:
+                    continue
+                try:
+                    with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                        for line_num, line in enumerate(f, 1):
+                            if MONGO_INJECTION_PATTERN.search(line):
+                                findings_by_file.setdefault(rel_path, []).append(
+                                    (line_num, "Potential NoSQL/MongoDB injection: unescaped request body passed directly to query")
+                                )
+                            if INSECURE_DB_SSL.search(line):
+                                findings_by_file.setdefault(rel_path, []).append(
+                                    (line_num, "Insecure database connection: SSL is disabled or certificate verification is bypassed")
+                                )
+                except Exception:
+                    pass
                     
     # Output findings
     if not findings_by_file:

package/scripts/check_gitignore.py

@@ -2,6 +2,25 @@
 import os
 import sys
 import fnmatch
+import subprocess
+
+# Ensure stdout supports UTF-8 on Windows
+if hasattr(sys.stdout, 'reconfigure'):
+    sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+
+def is_tracked_by_git(file_rel_path, repo_root):
+    """Check if a file is actively tracked in git index even if listed in .gitignore."""
+    try:
+        res = subprocess.run(
+            ['git', 'ls-files', '--error-unmatch', file_rel_path],
+            cwd=repo_root,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            check=False
+        )
+        return res.returncode == 0
+    except Exception:
+        return False
 
 # Potential local secret file patterns (glob format)
 SECRET_PATTERNS = [
@@ -97,43 +116,102 @@ def main():
     
     gitignore_path = os.path.join(target_dir, '.gitignore')
     has_gitignore = os.path.exists(gitignore_path)
-    
     gitignore_patterns = parse_gitignore(gitignore_path) if has_gitignore else []
     
+    dockerignore_path = os.path.join(target_dir, '.dockerignore')
+    has_dockerfile = any(
+        os.path.exists(os.path.join(target_dir, f)) 
+        for f in ['Dockerfile', 'docker-compose.yml', 'compose.yaml', 'compose.yml']
+    )
+    dockerignore_patterns = parse_gitignore(dockerignore_path) if os.path.exists(dockerignore_path) else []
+
     secret_files_found = []
     unignored_secrets = []
+    docker_exposed_secrets = []
+    npmrc_findings = []
+    git_tracked_secrets = []
     
     for root, dirs, files in os.walk(target_dir):
         # Exclude directories
         dirs[:] = [d for d in dirs if d not in {'node_modules', '.git', 'dist', 'build', '.next', '.svelte-kit'}]
         
+        # Check if current directory has its own .gitignore (monorepo support)
+        local_gi = os.path.join(root, '.gitignore')
+        active_patterns = list(gitignore_patterns)
+        if root != target_dir and os.path.exists(local_gi):
+            active_patterns.extend(parse_gitignore(local_gi))
+            
         for file in files:
+            file_path = os.path.join(root, file)
+            rel_path = os.path.relpath(file_path, target_dir)
+            
+            # Check .npmrc for hardcoded auth tokens
+            if file == '.npmrc':
+                try:
+                    with open(file_path, 'r', encoding='utf-8', errors='ignore') as nf:
+                        for line in nf:
+                            if '_authToken=' in line or '_auth=' in line:
+                                npmrc_findings.append(f"{rel_path} contains hardcoded npm authToken")
+                                break
+                except Exception:
+                    pass
+
             if is_secret_file(file):
-                file_path = os.path.join(root, file)
-                rel_path = os.path.relpath(file_path, target_dir)
-                
-                if is_ignored(rel_path, gitignore_patterns):
+                if is_ignored(rel_path, active_patterns):
                     secret_files_found.append((rel_path, True))
+                    # Check if git is actively tracking it despite .gitignore
+                    if is_tracked_by_git(rel_path, target_dir):
+                        git_tracked_secrets.append(rel_path)
                 else:
                     secret_files_found.append((rel_path, False))
                     unignored_secrets.append(rel_path)
                     
-    if not secret_files_found:
-        print("PASS: No local secret files (like .env) were detected in the project.")
-        sys.exit(0)
-        
+                # If Dockerfile is present, ensure secrets are also in .dockerignore
+                if has_dockerfile:
+                    if not os.path.exists(dockerignore_path) or not is_ignored(rel_path, dockerignore_patterns):
+                        docker_exposed_secrets.append(rel_path)
+                    
+    has_issues = False
+    
     if unignored_secrets:
+        has_issues = True
         print("FAIL: The following local secret files are NOT excluded by .gitignore:")
         for sf in unignored_secrets:
             print(f"  - {sf}")
         if not has_gitignore:
             print("  (Note: No .gitignore file was found in the project root)")
-        sys.exit(1)
-    else:
-        print("PASS: All detected local secret files are correctly listed in .gitignore:")
-        for sf, ignored in secret_files_found:
-            print(f"  - {sf} (ignored)")
+
+    if git_tracked_secrets:
+        has_issues = True
+        print("FAIL (Git Index Leak): The following secret files are listed in .gitignore but are STILL TRACKED by Git:")
+        for sf in git_tracked_secrets:
+            print(f"  - {sf} (Fix: run 'git rm --cached {sf}')")
+            
+    if docker_exposed_secrets:
+        has_issues = True
+        print("FAIL (Docker Risk): Dockerfile detected, but secret files are NOT excluded in .dockerignore:")
+        for sf in docker_exposed_secrets:
+            print(f"  - {sf} (risk of baking secrets into container images)")
+        if not os.path.exists(dockerignore_path):
+            print("  (Note: No .dockerignore file was found in the project root)")
+
+    if npmrc_findings:
+        has_issues = True
+        print("FAIL (NPM Credential Leak):")
+        for hit in npmrc_findings:
+            print(f"  - {hit}")
+
+    if not secret_files_found and not has_issues:
+        print("PASS: No local secret files (like .env) were detected in the project.")
         sys.exit(0)
+        
+    if has_issues:
+        sys.exit(1)
+        
+    print("PASS: All detected local secret files are correctly listed in .gitignore and not tracked by Git:")
+    for sf, ignored in secret_files_found:
+        print(f"  - {sf} (ignored)")
+    sys.exit(0)
 
 if __name__ == '__main__':
     main()