cli-jaw 0.1.6 → 0.1.8

package/skills_ref/insecure-defaults/README.md

@@ -1,45 +0,0 @@
-# Insecure Defaults Detection
-
-Security skill for detecting insecure default configurations that create vulnerabilities when applications run with missing or incomplete configuration.
-
-## Overview
-
-The `insecure-defaults` skill helps identify security vulnerabilities caused by:
-
-- **Hardcoded fallback secrets** (JWT keys, API keys, session secrets)
-- **Default credentials** (admin/admin, root/password)
-- **Weak cryptographic defaults** (MD5, DES, ECB mode)
-- **Permissive access control** (CORS *, public by default)
-- **Missing security configuration** that causes fail-open behavior
-
-**Critical Distinction:** This skill emphasizes **fail-secure vs. fail-open** behavior. Applications that crash without proper configuration are safe; applications that run with insecure defaults are vulnerable.
-
-## Installation
-
-```bash
-cd parent-folder/skills
-/plugin install ./plugins/insecure-defaults
-```
-
-Or from the plugin marketplace:
-```bash
-/plugin install insecure-defaults
-```
-
-## When to Use
-
-Use this skill when:
-
-- **Security auditing** production applications or services
-- **Configuration review** of deployment manifests (Docker, Kubernetes, IaC)
-- **Pre-production checks** before deploying new services
-- **Code review** of authentication, authorization, or cryptographic code
-- **Environment variable handling** analysis for secrets management
-- **API security review** checking CORS, rate limiting, authentication
-- **Third-party integration** review for hardcoded test credentials
-
-## Usage
-
-```
-Audit this codebase for insecure defaults—focus on environment variable fallbacks and authentication configuration
-```

package/skills_ref/insecure-defaults/skills/insecure-defaults/SKILL.md

@@ -1,117 +0,0 @@
----
-name: insecure-defaults
-description: "Detects fail-open insecure defaults (hardcoded secrets, weak auth, permissive security) that allow apps to run insecurely in production. Use when auditing security, reviewing config management, or analyzing environment variable handling."
-allowed-tools:
-  - Read
-  - Grep
-  - Glob
-  - Bash
----
-
-# Insecure Defaults Detection
-
-Finds **fail-open** vulnerabilities where apps run insecurely with missing configuration. Distinguishes exploitable defaults from fail-secure patterns that crash safely.
-
-- **Fail-open (CRITICAL):** `SECRET = env.get('KEY') or 'default'` → App runs with weak secret
-- **Fail-secure (SAFE):** `SECRET = env['KEY']` → App crashes if missing
-
-## When to Use
-
-- **Security audits** of production applications (auth, crypto, API security)
-- **Configuration review** of deployment files, IaC templates, Docker configs
-- **Code review** of environment variable handling and secrets management
-- **Pre-deployment checks** for hardcoded credentials or weak defaults
-
-## When NOT to Use
-
-Do not use this skill for:
-- **Test fixtures** explicitly scoped to test environments (files in `test/`, `spec/`, `__tests__/`)
-- **Example/template files** (`.example`, `.template`, `.sample` suffixes)
-- **Development-only tools** (local Docker Compose for dev, debug scripts)
-- **Documentation examples** in README.md or docs/ directories
-- **Build-time configuration** that gets replaced during deployment
-- **Crash-on-missing behavior** where app won't start without proper config (fail-secure)
-
-When in doubt: trace the code path to determine if the app runs with the default or crashes.
-
-## Rationalizations to Reject
-
-- **"It's just a development default"** → If it reaches production code, it's a finding
-- **"The production config overrides it"** → Verify prod config exists; code-level vulnerability remains if not
-- **"This would never run without proper config"** → Prove it with code trace; many apps fail silently
-- **"It's behind authentication"** → Defense in depth; compromised session still exploits weak defaults
-- **"We'll fix it before release"** → Document now; "later" rarely comes
-
-## Workflow
-
-Follow this workflow for every potential finding:
-
-### 1. SEARCH: Perform Project Discovery and Find Insecure Defaults
-
-Determine language, framework, and project conventions. Use this information to further discover things like secret storage locations, secret usage patterns, credentialed third-party integrations, cryptography, and any other relevant configuration. Further use information to analyze insecure default configurations.
-
-**Example**
-Search for patterns in `**/config/`, `**/auth/`, `**/database/`, and env files:
-- **Fallback secrets:** `getenv.*\) or ['"]`, `process\.env\.[A-Z_]+ \|\| ['"]`, `ENV\.fetch.*default:`
-- **Hardcoded credentials:** `password.*=.*['"][^'"]{8,}['"]`, `api[_-]?key.*=.*['"][^'"]+['"]`
-- **Weak defaults:** `DEBUG.*=.*true`, `AUTH.*=.*false`, `CORS.*=.*\*`
-- **Crypto algorithms:** `MD5|SHA1|DES|RC4|ECB` in security contexts
-
-Tailor search approach based on discovery results.
-
-Focus on production-reachable code, not test fixtures or example files.
-
-### 2. VERIFY: Actual Behavior
-For each match, trace the code path to understand runtime behavior.
-
-**Questions to answer:**
-- When is this code executed? (Startup vs. runtime)
-- What happens if a configuration variable is missing?
-- Is there validation that enforces secure configuration?
-
-### 3. CONFIRM: Production Impact
-Determine if this issue reaches production:
-
-If production config provides the variable → Lower severity (but still a code-level vulnerability)
-If production config missing or uses default → CRITICAL
-
-### 4. REPORT: with Evidence
-
-**Example report:**
-```
-Finding: Hardcoded JWT Secret Fallback
-Location: src/auth/jwt.ts:15
-Pattern: const secret = process.env.JWT_SECRET || 'default';
-
-Verification: App starts without JWT_SECRET; secret used in jwt.sign() at line 42
-Production Impact: Dockerfile missing JWT_SECRET
-Exploitation: Attacker forges JWTs using 'default', gains unauthorized access
-```
-
-## Quick Verification Checklist
-
-**Fallback Secrets:** `SECRET = env.get(X) or Y`
-→ Verify: App starts without env var? Secret used in crypto/auth?
-→ Skip: Test fixtures, example files
-
-**Default Credentials:** Hardcoded `username`/`password` pairs
-→ Verify: Active in deployed config? No runtime override?
-→ Skip: Disabled accounts, documentation examples
-
-**Fail-Open Security:** `AUTH_REQUIRED = env.get(X, 'false')`
-→ Verify: Default is insecure (false/disabled/permissive)?
-→ Safe: App crashes or default is secure (true/enabled/restricted)
-
-**Weak Crypto:** MD5/SHA1/DES/RC4/ECB in security contexts
-→ Verify: Used for passwords, encryption, or tokens?
-→ Skip: Checksums, non-security hashing
-
-**Permissive Access:** CORS `*`, permissions `0777`, public-by-default
-→ Verify: Default allows unauthorized access?
-→ Skip: Explicitly configured permissiveness with justification
-
-**Debug Features:** Stack traces, introspection, verbose errors
-→ Verify: Enabled by default? Exposed in responses?
-→ Skip: Logging-only, not user-facing
-
-For detailed examples and counter-examples, see [examples.md](references/examples.md).

package/skills_ref/insecure-defaults/skills/insecure-defaults/references/examples.md

@@ -1,409 +0,0 @@
-# Insecure Defaults: Examples and Counter-Examples
-
-This document provides detailed examples for each category in the Quick Verification Checklist, showing both vulnerable patterns (report these) and secure patterns (skip these).
-
-## Fallback Secrets
-
-### ❌ VULNERABLE - Report These
-
-**Python: Environment variable with fallback**
-```python
-# File: src/auth/jwt.py
-SECRET_KEY = os.environ.get('SECRET_KEY', 'dev-secret-key-123')
-
-# Used in security context
-def create_token(user_id):
-    return jwt.encode({'user_id': user_id}, SECRET_KEY, algorithm='HS256')
-```
-**Why vulnerable:** App runs with known secret if `SECRET_KEY` is missing. Attacker can forge tokens.
-
-**JavaScript: Logical OR fallback**
-```javascript
-// File: config/database.js
-const DB_PASSWORD = process.env.DB_PASSWORD || 'admin123';
-
-const pool = new Pool({
-  user: 'admin',
-  password: DB_PASSWORD,
-  database: 'production'
-});
-```
-**Why vulnerable:** Database accepts hardcoded password in production if env var missing.
-
-**Ruby: fetch with default**
-```ruby
-# File: config/secrets.rb
-Rails.application.credentials.secret_key_base =
-  ENV.fetch('SECRET_KEY_BASE', 'fallback-secret-base')
-```
-**Why vulnerable:** Rails session encryption uses weak known key as fallback.
-
-### ✅ SECURE - Skip These
-
-**Fail-secure: Crashes without config**
-```python
-# File: src/auth/jwt.py
-SECRET_KEY = os.environ['SECRET_KEY']  # Raises KeyError if missing
-
-# App won't start without SECRET_KEY - fail-secure
-```
-
-**Explicit validation**
-```javascript
-// File: config/database.js
-if (!process.env.DB_PASSWORD) {
-  throw new Error('DB_PASSWORD environment variable required');
-}
-const DB_PASSWORD = process.env.DB_PASSWORD;
-```
-
-**Test fixtures (clearly scoped)**
-```python
-# File: tests/fixtures/auth.py
-TEST_SECRET = 'test-secret-key-123'  # OK - test-only
-
-# Usage in test
-def test_token_creation():
-    token = create_token('user1', secret=TEST_SECRET)
-```
-
----
-
-## Default Credentials
-
-### ❌ VULNERABLE - Report These
-
-**Hardcoded admin account**
-```python
-# File: src/models/user.py
-def bootstrap_admin():
-    """Create default admin account if none exists"""
-    if not User.query.filter_by(role='admin').first():
-        admin = User(
-            username='admin',
-            password=hash_password('admin123'),
-            role='admin'
-        )
-        db.session.add(admin)
-        db.session.commit()
-```
-**Why vulnerable:** Default admin account created on first run with known credentials.
-
-**API key in code**
-```javascript
-// File: src/integrations/payment.js
-const STRIPE_API_KEY = process.env.STRIPE_KEY || 'sk_tes...';
-
-const stripe = require('stripe')(STRIPE_API_KEY);
-```
-**Why vulnerable:** Uses test API key if env var missing. Might reach production.
-
-**Database connection string**
-```java
-// File: DatabaseConfig.java
-private static final String DB_URL = System.getenv().getOrDefault(
-    "DATABASE_URL",
-    "postgresql://admin:password@localhost:5432/prod"
-);
-```
-**Why vulnerable:** Hardcoded database credentials as fallback.
-
-### ✅ SECURE - Skip These
-
-**Disabled default account**
-```python
-# File: src/models/user.py
-def bootstrap_admin():
-    """Admin account MUST be configured via environment"""
-    username = os.environ['ADMIN_USERNAME']
-    password = os.environ['ADMIN_PASSWORD']
-
-    if not User.query.filter_by(username=username).first():
-        admin = User(username=username, password=hash_password(password), role='admin')
-        db.session.add(admin)
-```
-
-**Example/documentation credentials**
-```bash
-# File: README.md
-## Setup
-
-Configure your API key:
-```bash
-export STRIPE_KEY='sk_tes...'  # Example only
-```
-```
-
-**Test fixture credentials**
-```python
-# File: tests/conftest.py
-@pytest.fixture
-def test_user():
-    return User(username='test_user', password='test_pass')  # OK - test scope
-```
-
----
-
-## Fail-Open Security
-
-### ❌ VULNERABLE - Report These
-
-**Authentication disabled by default**
-```python
-# File: config/security.py
-REQUIRE_AUTH = os.getenv('REQUIRE_AUTH', 'false').lower() == 'true'
-
-@app.before_request
-def check_auth():
-    if not REQUIRE_AUTH:
-        return  # Skip auth check
-    # ... auth logic
-```
-**Why vulnerable:** Default is no authentication. App runs insecurely if env var missing.
-
-**CORS allows all origins**
-```javascript
-// File: server.js
-const allowedOrigins = process.env.ALLOWED_ORIGINS || '*';
-
-app.use(cors({ origin: allowedOrigins }));
-```
-**Why vulnerable:** Default allows requests from any origin. XSS/CSRF risk.
-
-**Debug mode enabled by default**
-```python
-# File: config.py
-DEBUG = os.getenv('DEBUG', 'true').lower() != 'false'  # Default: true
-
-if DEBUG:
-    app.config['DEBUG'] = True
-    app.config['PROPAGATE_EXCEPTIONS'] = True
-```
-**Why vulnerable:** Debug mode default. Stack traces leak sensitive info in production.
-
-### ✅ SECURE - Skip These
-
-**Authentication required by default**
-```python
-# File: config/security.py
-REQUIRE_AUTH = os.getenv('REQUIRE_AUTH', 'true').lower() == 'true'  # Default: true
-
-# Or better - crash if not explicitly configured
-REQUIRE_AUTH = os.environ['REQUIRE_AUTH'].lower() == 'true'
-```
-
-**CORS requires explicit configuration**
-```javascript
-// File: server.js
-if (!process.env.ALLOWED_ORIGINS) {
-  throw new Error('ALLOWED_ORIGINS must be configured');
-}
-const allowedOrigins = process.env.ALLOWED_ORIGINS.split(',');
-
-app.use(cors({ origin: allowedOrigins }));
-```
-
-**Debug mode disabled by default**
-```python
-# File: config.py
-DEBUG = os.getenv('DEBUG', 'false').lower() == 'true'  # Default: false
-```
-
----
-
-## Weak Crypto
-
-### ❌ VULNERABLE - Report These
-
-**MD5 for password hashing**
-```python
-# File: src/auth/passwords.py
-import hashlib
-
-def hash_password(password):
-    """Hash user password"""
-    return hashlib.md5(password.encode()).hexdigest()
-```
-**Why vulnerable:** MD5 is cryptographically broken. Rainbow tables exist. Use bcrypt/Argon2.
-
-**DES encryption for sensitive data**
-```java
-// File: Encryption.java
-public static byte[] encrypt(String data, byte[] key) {
-    Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
-    SecretKeySpec secretKey = new SecretKeySpec(key, "DES");
-    cipher.init(Cipher.ENCRYPT_MODE, secretKey);
-    return cipher.doFinal(data.getBytes());
-}
-```
-**Why vulnerable:** DES has 56-bit keys (brute-forceable). ECB mode leaks patterns.
-
-**SHA1 for signature verification**
-```javascript
-// File: webhooks.js
-function verifySignature(payload, signature) {
-  const hmac = crypto.createHmac('sha1', WEBHOOK_SECRET);
-  const computed = hmac.update(payload).digest('hex');
-  return computed === signature;
-}
-```
-**Why vulnerable:** SHA1 collisions exist. Use SHA256 or better.
-
-### ✅ SECURE - Skip These
-
-**Weak crypto for non-security checksums**
-```python
-# File: src/utils/cache.py
-import hashlib
-
-def cache_key(data):
-    """Generate cache key - not security-sensitive"""
-    return hashlib.md5(data.encode()).hexdigest()  # OK - just for cache lookup
-```
-
-**Modern crypto for passwords**
-```python
-# File: src/auth/passwords.py
-import bcrypt
-
-def hash_password(password):
-    return bcrypt.hashpw(password.encode(), bcrypt.gensalt())
-```
-
-**Strong encryption**
-```java
-// File: Encryption.java
-Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
-// 256-bit key, authenticated encryption
-```
-
----
-
-## Permissive Access
-
-### ❌ VULNERABLE - Report These
-
-**File permissions world-writable**
-```python
-# File: src/storage/files.py
-def create_secure_file(path):
-    fd = os.open(path, os.O_CREAT | os.O_WRONLY, 0o666)  # rw-rw-rw-
-    return fd
-```
-**Why vulnerable:** Any user can write to file. Should be 0o600 or 0o644.
-
-**S3 bucket public by default**
-```python
-# File: infrastructure/storage.py
-def create_storage_bucket(name):
-    bucket = s3.create_bucket(
-        Bucket=name,
-        ACL='public-read'  # Publicly readable by default
-    )
-```
-**Why vulnerable:** Sensitive data exposed publicly. Should require explicit configuration.
-
-**API allows any origin**
-```python
-# File: app.py
-@app.after_request
-def after_request(response):
-    response.headers['Access-Control-Allow-Origin'] = '*'
-    response.headers['Access-Control-Allow-Credentials'] = 'true'
-    return response
-```
-**Why vulnerable:** CORS misconfiguration. Allows credential theft from any site.
-
-### ✅ SECURE - Skip These
-
-**Explicitly configured permissiveness with justification**
-```python
-# File: src/storage/public_assets.py
-def create_public_asset(path):
-    """Create world-readable asset for CDN distribution"""
-    # Intentionally public - static assets only
-    fd = os.open(path, os.O_CREAT | os.O_WRONLY, 0o644)
-    return fd
-```
-
-**Restrictive by default**
-```python
-# File: infrastructure/storage.py
-def create_storage_bucket(name, public=False):
-    acl = 'public-read' if public else 'private'
-    if public:
-        logger.warning(f'Creating PUBLIC bucket: {name}')
-    bucket = s3.create_bucket(Bucket=name, ACL=acl)
-```
-
----
-
-## Debug Features
-
-### ❌ VULNERABLE - Report These
-
-**Stack traces in API responses**
-```python
-# File: app.py
-@app.errorhandler(Exception)
-def handle_error(error):
-    return jsonify({
-        'error': str(error),
-        'traceback': traceback.format_exc()  # Leaks internal paths, library versions
-    }), 500
-```
-**Why vulnerable:** Exposes internal implementation details to attackers.
-
-**GraphQL introspection enabled**
-```javascript
-// File: server.js
-const server = new ApolloServer({
-  typeDefs,
-  resolvers,
-  introspection: true,  // Enabled in production
-  playground: true
-});
-```
-**Why vulnerable:** Attackers can discover entire API schema, including admin-only fields.
-
-**Verbose error messages**
-```java
-// File: UserController.java
-catch (SQLException e) {
-    return ResponseEntity.status(500).body(
-        "Database error: " + e.getMessage()  // Leaks table names, constraints
-    );
-}
-```
-**Why vulnerable:** SQL error messages reveal database structure.
-
-### ✅ SECURE - Skip These
-
-**Debug features in logging only**
-```python
-# File: app.py
-@app.errorhandler(Exception)
-def handle_error(error):
-    logger.exception('Request failed', exc_info=error)  # Logs full trace
-    return jsonify({'error': 'Internal server error'}), 500  # Generic to user
-```
-
-**Environment-aware debug settings**
-```javascript
-// File: server.js
-const server = new ApolloServer({
-  typeDefs,
-  resolvers,
-  introspection: process.env.NODE_ENV !== 'production',
-  playground: process.env.NODE_ENV !== 'production'
-});
-```
-
-**Generic user-facing errors**
-```java
-// File: UserController.java
-catch (SQLException e) {
-    logger.error("Database error", e);  // Full details to logs
-    return ResponseEntity.status(500).body("Unable to process request");  // Generic
-}
-```

package/skills_ref/jupyter-notebook/SKILL.md

@@ -1,107 +0,0 @@
----
-name: "jupyter-notebook"
-description: "Use when the user asks to create, scaffold, or edit Jupyter notebooks (`.ipynb`) for experiments, explorations, or tutorials; prefer the bundled templates and run the helper script `new_notebook.py` to generate a clean starting notebook."
----
-
-
-# Jupyter Notebook Skill
-
-Create clean, reproducible Jupyter notebooks for two primary modes:
-
-- Experiments and exploratory analysis
-- Tutorials and teaching-oriented walkthroughs
-
-Prefer the bundled templates and the helper script for consistent structure and fewer JSON mistakes.
-
-## When to use
-- Create a new `.ipynb` notebook from scratch.
-- Convert rough notes or scripts into a structured notebook.
-- Refactor an existing notebook to be more reproducible and skimmable.
-- Build experiments or tutorials that will be read or re-run by other people.
-
-## Decision tree
-- If the request is exploratory, analytical, or hypothesis-driven, choose `experiment`.
-- If the request is instructional, step-by-step, or audience-specific, choose `tutorial`.
-- If editing an existing notebook, treat it as a refactor: preserve intent and improve structure.
-
-## Skill path (set once)
-
-```bash
-export CODEX_HOME="${CODEX_HOME:-$HOME/.codex}"
-export JUPYTER_NOTEBOOK_CLI="$CODEX_HOME/skills/jupyter-notebook/scripts/new_notebook.py"
-```
-
-User-scoped skills install under `$CODEX_HOME/skills` (default: `~/.codex/skills`).
-
-## Workflow
-1. Lock the intent.
-Identify the notebook kind: `experiment` or `tutorial`.
-Capture the objective, audience, and what "done" looks like.
-
-2. Scaffold from the template.
-Use the helper script to avoid hand-authoring raw notebook JSON.
-
-```bash
-uv run --python 3.12 python "$JUPYTER_NOTEBOOK_CLI" \
-  --kind experiment \
-  --title "Compare prompt variants" \
-  --out output/jupyter-notebook/compare-prompt-variants.ipynb
-```
-
-```bash
-uv run --python 3.12 python "$JUPYTER_NOTEBOOK_CLI" \
-  --kind tutorial \
-  --title "Intro to embeddings" \
-  --out output/jupyter-notebook/intro-to-embeddings.ipynb
-```
-
-3. Fill the notebook with small, runnable steps.
-Keep each code cell focused on one step.
-Add short markdown cells that explain the purpose and expected result.
-Avoid large, noisy outputs when a short summary works.
-
-4. Apply the right pattern.
-For experiments, follow `references/experiment-patterns.md`.
-For tutorials, follow `references/tutorial-patterns.md`.
-
-5. Edit safely when working with existing notebooks.
-Preserve the notebook structure; avoid reordering cells unless it improves the top-to-bottom story.
-Prefer targeted edits over full rewrites.
-If you must edit raw JSON, review `references/notebook-structure.md` first.
-
-6. Validate the result.
-Run the notebook top-to-bottom when the environment allows.
-If execution is not possible, say so explicitly and call out how to validate locally.
-Use the final pass checklist in `references/quality-checklist.md`.
-
-## Templates and helper script
-- Templates live in `assets/experiment-template.ipynb` and `assets/tutorial-template.ipynb`.
-- The helper script loads a template, updates the title cell, and writes a notebook.
-
-Script path:
-- `$JUPYTER_NOTEBOOK_CLI` (installed default: `$CODEX_HOME/skills/jupyter-notebook/scripts/new_notebook.py`)
-
-## Temp and output conventions
-- Use `tmp/jupyter-notebook/` for intermediate files; delete when done.
-- Write final artifacts under `output/jupyter-notebook/` when working in this repo.
-- Use stable, descriptive filenames (for example, `ablation-temperature.ipynb`).
-
-## Dependencies (install only when needed)
-Prefer `uv` for dependency management.
-
-Optional Python packages for local notebook execution:
-
-```bash
-uv pip install jupyterlab ipykernel
-```
-
-The bundled scaffold script uses only the Python standard library and does not require extra dependencies.
-
-## Environment
-No required environment variables.
-
-## Reference map
-- `references/experiment-patterns.md`: experiment structure and heuristics.
-- `references/tutorial-patterns.md`: tutorial structure and teaching flow.
-- `references/notebook-structure.md`: notebook JSON shape and safe editing rules.
-- `references/quality-checklist.md`: final validation checklist.