@namch/agent-assistant 1.0.0 → 1.0.1

package/skills/react-ui-patterns/SKILL.md

@@ -0,0 +1,289 @@
+---
+name: react-ui-patterns
+description: Modern React UI patterns for loading states, error handling, and data fetching. Use when building UI components, handling async data, or managing UI states.
+---
+
+# React UI Patterns
+
+## Core Principles
+
+1. **Never show stale UI** - Loading spinners only when actually loading
+2. **Always surface errors** - Users must know when something fails
+3. **Optimistic updates** - Make the UI feel instant
+4. **Progressive disclosure** - Show content as it becomes available
+5. **Graceful degradation** - Partial data is better than no data
+
+## Loading State Patterns
+
+### The Golden Rule
+
+**Show loading indicator ONLY when there's no data to display.**
+
+```typescript
+// CORRECT - Only show loading when no data exists
+const { data, loading, error } = useGetItemsQuery();
+
+if (error) return <ErrorState error={error} onRetry={refetch} />;
+if (loading && !data) return <LoadingState />;
+if (!data?.items.length) return <EmptyState />;
+
+return <ItemList items={data.items} />;
+```
+
+```typescript
+// WRONG - Shows spinner even when we have cached data
+if (loading) return <LoadingState />; // Flashes on refetch!
+```
+
+### Loading State Decision Tree
+
+```
+Is there an error?
+  → Yes: Show error state with retry option
+  → No: Continue
+
+Is it loading AND we have no data?
+  → Yes: Show loading indicator (spinner/skeleton)
+  → No: Continue
+
+Do we have data?
+  → Yes, with items: Show the data
+  → Yes, but empty: Show empty state
+  → No: Show loading (fallback)
+```
+
+### Skeleton vs Spinner
+
+| Use Skeleton When | Use Spinner When |
+|-------------------|------------------|
+| Known content shape | Unknown content shape |
+| List/card layouts | Modal actions |
+| Initial page load | Button submissions |
+| Content placeholders | Inline operations |
+
+## Error Handling Patterns
+
+### The Error Handling Hierarchy
+
+```
+1. Inline error (field-level) → Form validation errors
+2. Toast notification → Recoverable errors, user can retry
+3. Error banner → Page-level errors, data still partially usable
+4. Full error screen → Unrecoverable, needs user action
+```
+
+### Always Show Errors
+
+**CRITICAL: Never swallow errors silently.**
+
+```typescript
+// CORRECT - Error always surfaced to user
+const [createItem, { loading }] = useCreateItemMutation({
+  onCompleted: () => {
+    toast.success({ title: 'Item created' });
+  },
+  onError: (error) => {
+    console.error('createItem failed:', error);
+    toast.error({ title: 'Failed to create item' });
+  },
+});
+
+// WRONG - Error silently caught, user has no idea
+const [createItem] = useCreateItemMutation({
+  onError: (error) => {
+    console.error(error); // User sees nothing!
+  },
+});
+```
+
+### Error State Component Pattern
+
+```typescript
+interface ErrorStateProps {
+  error: Error;
+  onRetry?: () => void;
+  title?: string;
+}
+
+const ErrorState = ({ error, onRetry, title }: ErrorStateProps) => (
+  <div className="error-state">
+    <Icon name="exclamation-circle" />
+    <h3>{title ?? 'Something went wrong'}</h3>
+    <p>{error.message}</p>
+    {onRetry && (
+      <Button onClick={onRetry}>Try Again</Button>
+    )}
+  </div>
+);
+```
+
+## Button State Patterns
+
+### Button Loading State
+
+```tsx
+<Button
+  onClick={handleSubmit}
+  isLoading={isSubmitting}
+  disabled={!isValid || isSubmitting}
+>
+  Submit
+</Button>
+```
+
+### Disable During Operations
+
+**CRITICAL: Always disable triggers during async operations.**
+
+```tsx
+// CORRECT - Button disabled while loading
+<Button
+  disabled={isSubmitting}
+  isLoading={isSubmitting}
+  onClick={handleSubmit}
+>
+  Submit
+</Button>
+
+// WRONG - User can tap multiple times
+<Button onClick={handleSubmit}>
+  {isSubmitting ? 'Submitting...' : 'Submit'}
+</Button>
+```
+
+## Empty States
+
+### Empty State Requirements
+
+Every list/collection MUST have an empty state:
+
+```tsx
+// WRONG - No empty state
+return <FlatList data={items} />;
+
+// CORRECT - Explicit empty state
+return (
+  <FlatList
+    data={items}
+    ListEmptyComponent={<EmptyState />}
+  />
+);
+```
+
+### Contextual Empty States
+
+```tsx
+// Search with no results
+<EmptyState
+  icon="search"
+  title="No results found"
+  description="Try different search terms"
+/>
+
+// List with no items yet
+<EmptyState
+  icon="plus-circle"
+  title="No items yet"
+  description="Create your first item"
+  action={{ label: 'Create Item', onClick: handleCreate }}
+/>
+```
+
+## Form Submission Pattern
+
+```tsx
+const MyForm = () => {
+  const [submit, { loading }] = useSubmitMutation({
+    onCompleted: handleSuccess,
+    onError: handleError,
+  });
+
+  const handleSubmit = async () => {
+    if (!isValid) {
+      toast.error({ title: 'Please fix errors' });
+      return;
+    }
+    await submit({ variables: { input: values } });
+  };
+
+  return (
+    <form>
+      <Input
+        value={values.name}
+        onChange={handleChange('name')}
+        error={touched.name ? errors.name : undefined}
+      />
+      <Button
+        type="submit"
+        onClick={handleSubmit}
+        disabled={!isValid || loading}
+        isLoading={loading}
+      >
+        Submit
+      </Button>
+    </form>
+  );
+};
+```
+
+## Anti-Patterns
+
+### Loading States
+
+```typescript
+// WRONG - Spinner when data exists (causes flash)
+if (loading) return <Spinner />;
+
+// CORRECT - Only show loading without data
+if (loading && !data) return <Spinner />;
+```
+
+### Error Handling
+
+```typescript
+// WRONG - Error swallowed
+try {
+  await mutation();
+} catch (e) {
+  console.log(e); // User has no idea!
+}
+
+// CORRECT - Error surfaced
+onError: (error) => {
+  console.error('operation failed:', error);
+  toast.error({ title: 'Operation failed' });
+}
+```
+
+### Button States
+
+```typescript
+// WRONG - Button not disabled during submission
+<Button onClick={submit}>Submit</Button>
+
+// CORRECT - Disabled and shows loading
+<Button onClick={submit} disabled={loading} isLoading={loading}>
+  Submit
+</Button>
+```
+
+## Checklist
+
+Before completing any UI component:
+
+**UI States:**
+- [ ] Error state handled and shown to user
+- [ ] Loading state shown only when no data exists
+- [ ] Empty state provided for collections
+- [ ] Buttons disabled during async operations
+- [ ] Buttons show loading indicator when appropriate
+
+**Data & Mutations:**
+- [ ] Mutations have onError handler
+- [ ] All user actions have feedback (toast/visual)
+
+## Integration with Other Skills
+
+- **graphql-schema**: Use mutation patterns with proper error handling
+- **testing-patterns**: Test all UI states (loading, error, empty, success)
+- **formik-patterns**: Apply form submission patterns

package/skills/red-team-tools/SKILL.md

@@ -0,0 +1,310 @@
+---
+name: Red Team Tools and Methodology
+description: This skill should be used when the user asks to "follow red team methodology", "perform bug bounty hunting", "automate reconnaissance", "hunt for XSS vulnerabilities", "enumerate subdomains", or needs security researcher techniques and tool configurations from top bug bounty hunters.
+metadata:
+  author: zebbern
+  version: "1.1"
+---
+
+# Red Team Tools and Methodology
+
+## Purpose
+
+Implement proven methodologies and tool workflows from top security researchers for effective reconnaissance, vulnerability discovery, and bug bounty hunting. Automate common tasks while maintaining thorough coverage of attack surfaces.
+
+## Inputs/Prerequisites
+
+- Target scope definition (domains, IP ranges, applications)
+- Linux-based attack machine (Kali, Ubuntu)
+- Bug bounty program rules and scope
+- Tool dependencies installed (Go, Python, Ruby)
+- API keys for various services (Shodan, Censys, etc.)
+
+## Outputs/Deliverables
+
+- Comprehensive subdomain enumeration
+- Live host discovery and technology fingerprinting
+- Identified vulnerabilities and attack vectors
+- Automated recon pipeline outputs
+- Documented findings for reporting
+
+## Core Workflow
+
+### 1. Project Tracking and Acquisitions
+
+Set up reconnaissance tracking:
+
+```bash
+# Create project structure
+mkdir -p target/{recon,vulns,reports}
+cd target
+
+# Find acquisitions using Crunchbase
+# Search manually for subsidiary companies
+
+# Get ASN for targets
+amass intel -org "Target Company" -src
+
+# Alternative ASN lookup
+curl -s "https://bgp.he.net/search?search=targetcompany&commit=Search"
+```
+
+### 2. Subdomain Enumeration
+
+Comprehensive subdomain discovery:
+
+```bash
+# Create wildcards file
+echo "target.com" > wildcards
+
+# Run Amass passively
+amass enum -passive -d target.com -src -o amass_passive.txt
+
+# Run Amass actively
+amass enum -active -d target.com -src -o amass_active.txt
+
+# Use Subfinder
+subfinder -d target.com -silent -o subfinder.txt
+
+# Asset discovery
+cat wildcards | assetfinder --subs-only | anew domains.txt
+
+# Alternative subdomain tools
+findomain -t target.com -o
+
+# Generate permutations with dnsgen
+cat domains.txt | dnsgen - | httprobe > permuted.txt
+
+# Combine all sources
+cat amass_*.txt subfinder.txt | sort -u > all_subs.txt
+```
+
+### 3. Live Host Discovery
+
+Identify responding hosts:
+
+```bash
+# Check which hosts are live with httprobe
+cat domains.txt | httprobe -c 80 --prefer-https | anew hosts.txt
+
+# Use httpx for more details
+cat domains.txt | httpx -title -tech-detect -status-code -o live_hosts.txt
+
+# Alternative with massdns
+massdns -r resolvers.txt -t A -o S domains.txt > resolved.txt
+```
+
+### 4. Technology Fingerprinting
+
+Identify technologies for targeted attacks:
+
+```bash
+# Whatweb scanning
+whatweb -i hosts.txt -a 3 -v > tech_stack.txt
+
+# Nuclei technology detection
+nuclei -l hosts.txt -t technologies/ -o tech_nuclei.txt
+
+# Wappalyzer (if available)
+# Browser extension for manual review
+```
+
+### 5. Content Discovery
+
+Find hidden endpoints and files:
+
+```bash
+# Directory bruteforce with ffuf
+ffuf -ac -v -u https://target.com/FUZZ -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt
+
+# Historical URLs from Wayback
+waybackurls target.com | tee wayback.txt
+
+# Find all URLs with gau
+gau target.com | tee all_urls.txt
+
+# Parameter discovery
+cat all_urls.txt | grep "=" | sort -u > params.txt
+
+# Generate custom wordlist from historical data
+cat all_urls.txt | unfurl paths | sort -u > custom_wordlist.txt
+```
+
+### 6. Application Analysis (Jason Haddix Method)
+
+**Heat Map Priority Areas:**
+
+1. **File Uploads** - Test for injection, XXE, SSRF, shell upload
+2. **Content Types** - Filter Burp for multipart forms
+3. **APIs** - Look for hidden methods, lack of auth
+4. **Profile Sections** - Stored XSS, custom fields
+5. **Integrations** - SSRF through third parties
+6. **Error Pages** - Exotic injection points
+
+**Analysis Questions:**
+- How does the app pass data? (Params, API, Hybrid)
+- Where does the app talk about users? (UID, UUID endpoints)
+- Does the site have multi-tenancy or user levels?
+- Does it have a unique threat model?
+- How does the site handle XSS/CSRF?
+- Has the site had past writeups/exploits?
+
+### 7. Automated XSS Hunting
+
+```bash
+# ParamSpider for parameter extraction
+python3 paramspider.py --domain target.com -o params.txt
+
+# Filter with Gxss
+cat params.txt | Gxss -p test
+
+# Dalfox for XSS testing
+cat params.txt | dalfox pipe --mining-dict params.txt -o xss_results.txt
+
+# Alternative workflow
+waybackurls target.com | grep "=" | qsreplace '"><script>alert(1)</script>' | while read url; do
+    curl -s "$url" | grep -q 'alert(1)' && echo "$url"
+done > potential_xss.txt
+```
+
+### 8. Vulnerability Scanning
+
+```bash
+# Nuclei comprehensive scan
+nuclei -l hosts.txt -t ~/nuclei-templates/ -o nuclei_results.txt
+
+# Check for common CVEs
+nuclei -l hosts.txt -t cves/ -o cve_results.txt
+
+# Web vulnerabilities
+nuclei -l hosts.txt -t vulnerabilities/ -o vuln_results.txt
+```
+
+### 9. API Enumeration
+
+**Wordlists for API fuzzing:**
+
+```bash
+# Enumerate API endpoints
+ffuf -u https://target.com/api/FUZZ -w /usr/share/seclists/Discovery/Web-Content/api/api-endpoints.txt
+
+# Test API versions
+ffuf -u https://target.com/api/v1/FUZZ -w api_wordlist.txt
+ffuf -u https://target.com/api/v2/FUZZ -w api_wordlist.txt
+
+# Check for hidden methods
+for method in GET POST PUT DELETE PATCH; do
+    curl -X $method https://target.com/api/users -v
+done
+```
+
+### 10. Automated Recon Script
+
+```bash
+#!/bin/bash
+domain=$1
+
+if [[ -z $domain ]]; then
+    echo "Usage: ./recon.sh <domain>"
+    exit 1
+fi
+
+mkdir -p "$domain"
+
+# Subdomain enumeration
+echo "[*] Enumerating subdomains..."
+subfinder -d "$domain" -silent > "$domain/subs.txt"
+
+# Live host discovery
+echo "[*] Finding live hosts..."
+cat "$domain/subs.txt" | httpx -title -tech-detect -status-code > "$domain/live.txt"
+
+# URL collection
+echo "[*] Collecting URLs..."
+cat "$domain/live.txt" | waybackurls > "$domain/urls.txt"
+
+# Nuclei scanning
+echo "[*] Running Nuclei..."
+nuclei -l "$domain/live.txt" -o "$domain/nuclei.txt"
+
+echo "[+] Recon complete!"
+```
+
+## Quick Reference
+
+### Essential Tools
+
+| Tool | Purpose |
+|------|---------|
+| Amass | Subdomain enumeration |
+| Subfinder | Fast subdomain discovery |
+| httpx/httprobe | Live host detection |
+| ffuf | Content discovery |
+| Nuclei | Vulnerability scanning |
+| Burp Suite | Manual testing |
+| Dalfox | XSS automation |
+| waybackurls | Historical URL mining |
+
+### Key API Endpoints to Check
+
+```
+/api/v1/users
+/api/v1/admin
+/api/v1/profile
+/api/users/me
+/api/config
+/api/debug
+/api/swagger
+/api/graphql
+```
+
+### XSS Filter Testing
+
+```html
+<!-- Test encoding handling -->
+<h1><img><table>
+<script>
+%3Cscript%3E
+%253Cscript%253E
+%26lt;script%26gt;
+```
+
+## Constraints
+
+- Respect program scope boundaries
+- Avoid DoS or fuzzing on production without permission
+- Rate limit requests to avoid blocking
+- Some tools may generate false positives
+- API keys required for full functionality of some tools
+
+## Examples
+
+### Example 1: Quick Subdomain Recon
+
+```bash
+subfinder -d target.com | httpx -title | tee results.txt
+```
+
+### Example 2: XSS Hunting Pipeline
+
+```bash
+waybackurls target.com | grep "=" | qsreplace "test" | httpx -silent | dalfox pipe
+```
+
+### Example 3: Comprehensive Scan
+
+```bash
+# Full recon chain
+amass enum -d target.com | httpx | nuclei -t ~/nuclei-templates/
+```
+
+## Troubleshooting
+
+| Issue | Solution |
+|-------|----------|
+| Rate limited | Use proxy rotation, reduce concurrency |
+| Too many results | Focus on specific technology stacks |
+| False positives | Manually verify findings before reporting |
+| Missing subdomains | Combine multiple enumeration sources |
+| API key errors | Verify keys in config files |
+| Tools not found | Install Go tools with `go install` |