openclaw-node-harness 2.0.0

package/skills/prompt-guard/scripts/hivefence.py

@@ -0,0 +1,345 @@
+#!/usr/bin/env python3
+"""
+HiveFence API Client for prompt-guard
+Connects to the distributed threat intelligence network.
+
+Usage:
+    from hivefence import HiveFenceClient
+    
+    client = HiveFenceClient()
+    
+    # Report a detected threat
+    client.report_threat(
+        pattern_hash="sha256:...",
+        category="role_override",
+        severity=4,
+        description="Fake system prompt attempt"
+    )
+    
+    # Fetch latest approved patterns
+    patterns = client.fetch_latest()
+    
+    # Vote on pending pattern
+    client.vote(pattern_id, approve=True)
+"""
+
+import hashlib
+import json
+import os
+import urllib.request
+import urllib.error
+from typing import Optional, Dict, List, Any
+from dataclasses import dataclass
+from datetime import datetime
+
+API_BASE = "https://hivefence-api.seojoon-kim.workers.dev/api/v1"
+
+@dataclass
+class ThreatPattern:
+    """Represents a threat pattern from HiveFence network."""
+    id: str
+    pattern_hash: str
+    category: str
+    severity: int
+    description: Optional[str]
+    status: str  # pending, voting, approved, rejected
+    created_at: str
+    votes_up: int = 0
+    votes_down: int = 0
+
+@dataclass
+class ReportResult:
+    """Result of reporting a threat."""
+    success: bool
+    pattern_id: Optional[str] = None
+    message: Optional[str] = None
+    error: Optional[str] = None
+
+class HiveFenceClient:
+    """Client for HiveFence threat intelligence API."""
+    
+    def __init__(self, api_base: str = API_BASE, timeout: int = 10):
+        self.api_base = api_base
+        self.timeout = timeout
+        self.cache_file = os.path.expanduser("~/.clawdbot/hivefence_cache.json")
+        self._patterns_cache: List[ThreatPattern] = []
+        self._cache_loaded = False
+    
+    def _request(self, method: str, endpoint: str, data: Optional[dict] = None) -> Dict[str, Any]:
+        """Make HTTP request to HiveFence API."""
+        url = f"{self.api_base}{endpoint}"
+        
+        headers = {
+            "Content-Type": "application/json",
+            "User-Agent": "prompt-guard/2.6.0"
+        }
+        
+        body = json.dumps(data).encode("utf-8") if data else None
+        
+        req = urllib.request.Request(url, data=body, headers=headers, method=method)
+        
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                return json.loads(resp.read().decode("utf-8"))
+        except urllib.error.HTTPError as e:
+            return {"error": f"HTTP {e.code}: {e.reason}"}
+        except urllib.error.URLError as e:
+            return {"error": f"Network error: {e.reason}"}
+        except Exception as e:
+            return {"error": str(e)}
+    
+    @staticmethod
+    def hash_pattern(pattern: str) -> str:
+        """Generate SHA-256 hash of a pattern."""
+        return f"sha256:{hashlib.sha256(pattern.encode()).hexdigest()[:16]}"
+    
+    def report_threat(
+        self,
+        pattern: str,
+        category: str,
+        severity: int,
+        description: Optional[str] = None,
+        context: Optional[Dict] = None
+    ) -> ReportResult:
+        """
+        Report a detected threat pattern to HiveFence network.
+        
+        Args:
+            pattern: The attack pattern text or regex
+            category: Attack category (role_override, fake_system, jailbreak, etc.)
+            severity: Severity 1-5
+            description: Human-readable description
+            context: Optional context (source, timestamp, etc.)
+        
+        Returns:
+            ReportResult with success status and pattern ID
+        """
+        pattern_hash = self.hash_pattern(pattern)
+        
+        payload = {
+            "patternHash": pattern_hash,
+            "category": category,
+            "severity": min(max(severity, 1), 5),  # Clamp 1-5
+            "description": description or f"Detected by prompt-guard",
+        }
+        
+        if context:
+            payload["context"] = context
+        
+        result = self._request("POST", "/threats/report", payload)
+        
+        if "error" in result:
+            return ReportResult(success=False, error=result["error"])
+        
+        return ReportResult(
+            success=True,
+            pattern_id=result.get("id"),
+            message=result.get("message", "Reported successfully")
+        )
+    
+    def fetch_latest(self, limit: int = 50) -> List[ThreatPattern]:
+        """
+        Fetch latest approved threat patterns from HiveFence.
+        
+        Args:
+            limit: Maximum patterns to fetch
+        
+        Returns:
+            List of approved ThreatPattern objects
+        """
+        result = self._request("GET", f"/threats/latest?limit={limit}")
+        
+        if "error" in result:
+            # Return cached if network fails
+            return self._load_cache()
+        
+        patterns = []
+        for p in result.get("patterns", []):
+            patterns.append(ThreatPattern(
+                id=p.get("id", ""),
+                pattern_hash=p.get("pattern_hash", ""),
+                category=p.get("category", "unknown"),
+                severity=p.get("severity", 3),
+                description=p.get("description"),
+                status=p.get("status", "approved"),
+                created_at=p.get("created_at", ""),
+                votes_up=p.get("votes_up", 0),
+                votes_down=p.get("votes_down", 0),
+            ))
+        
+        # Cache results
+        self._patterns_cache = patterns
+        self._save_cache(patterns)
+        
+        return patterns
+    
+    def fetch_pending(self) -> List[ThreatPattern]:
+        """Fetch patterns pending validation/voting."""
+        result = self._request("GET", "/threats/pending")
+        
+        if "error" in result:
+            return []
+        
+        patterns = []
+        for p in result.get("patterns", []):
+            patterns.append(ThreatPattern(
+                id=p.get("id", ""),
+                pattern_hash=p.get("pattern_hash", ""),
+                category=p.get("category", "unknown"),
+                severity=p.get("severity", 3),
+                description=p.get("description"),
+                status=p.get("status", "pending"),
+                created_at=p.get("created_at", ""),
+                votes_up=p.get("votes_up", 0),
+                votes_down=p.get("votes_down", 0),
+            ))
+        
+        return patterns
+    
+    def vote(self, pattern_id: str, approve: bool, voter_id: Optional[str] = None) -> bool:
+        """
+        Vote on a pending threat pattern.
+        
+        Args:
+            pattern_id: ID of pattern to vote on
+            approve: True to approve, False to reject
+            voter_id: Optional voter identifier
+        
+        Returns:
+            True if vote was recorded
+        """
+        payload = {
+            "approve": approve,
+        }
+        if voter_id:
+            payload["voterId"] = voter_id
+        
+        result = self._request("POST", f"/threats/{pattern_id}/vote", payload)
+        
+        return "error" not in result
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get HiveFence network statistics."""
+        return self._request("GET", "/stats")
+    
+    def _save_cache(self, patterns: List[ThreatPattern]):
+        """Save patterns to local cache file."""
+        try:
+            cache_dir = os.path.dirname(self.cache_file)
+            if not os.path.exists(cache_dir):
+                os.makedirs(cache_dir, mode=0o700)
+            
+            data = {
+                "updated_at": datetime.utcnow().isoformat(),
+                "patterns": [
+                    {
+                        "id": p.id,
+                        "pattern_hash": p.pattern_hash,
+                        "category": p.category,
+                        "severity": p.severity,
+                        "description": p.description,
+                    }
+                    for p in patterns
+                ]
+            }
+            
+            with open(self.cache_file, "w") as f:
+                json.dump(data, f, indent=2)
+        except Exception:
+            pass  # Cache is optional
+    
+    def _load_cache(self) -> List[ThreatPattern]:
+        """Load patterns from local cache."""
+        if self._cache_loaded and self._patterns_cache:
+            return self._patterns_cache
+        
+        try:
+            if os.path.exists(self.cache_file):
+                with open(self.cache_file) as f:
+                    data = json.load(f)
+                
+                patterns = []
+                for p in data.get("patterns", []):
+                    patterns.append(ThreatPattern(
+                        id=p.get("id", ""),
+                        pattern_hash=p.get("pattern_hash", ""),
+                        category=p.get("category", "unknown"),
+                        severity=p.get("severity", 3),
+                        description=p.get("description"),
+                        status="cached",
+                        created_at=data.get("updated_at", ""),
+                    ))
+                
+                self._patterns_cache = patterns
+                self._cache_loaded = True
+                return patterns
+        except Exception:
+            pass
+        
+        return []
+
+
+# CLI interface
+if __name__ == "__main__":
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="HiveFence CLI")
+    parser.add_argument("command", choices=["stats", "latest", "pending", "report", "vote"])
+    parser.add_argument("--pattern", help="Pattern text for report")
+    parser.add_argument("--category", default="other", help="Attack category")
+    parser.add_argument("--severity", type=int, default=3, help="Severity 1-5")
+    parser.add_argument("--id", help="Pattern ID for voting")
+    parser.add_argument("--approve", action="store_true", help="Approve vote")
+    parser.add_argument("--reject", action="store_true", help="Reject vote")
+    parser.add_argument("--json", action="store_true", help="JSON output")
+    
+    args = parser.parse_args()
+    client = HiveFenceClient()
+    
+    if args.command == "stats":
+        stats = client.get_stats()
+        if args.json:
+            print(json.dumps(stats, indent=2))
+        else:
+            print(f"🐝 HiveFence Network Stats")
+            print(f"   Total patterns: {stats.get('patterns', {}).get('total', 0)}")
+            print(f"   Approved: {stats.get('patterns', {}).get('approved', 0)}")
+            print(f"   Pending: {stats.get('patterns', {}).get('pending', 0)}")
+    
+    elif args.command == "latest":
+        patterns = client.fetch_latest()
+        if args.json:
+            print(json.dumps([{"id": p.id, "category": p.category, "severity": p.severity} for p in patterns], indent=2))
+        else:
+            print(f"🛡️ Latest {len(patterns)} approved patterns:")
+            for p in patterns[:10]:
+                print(f"   [{p.severity}/5] {p.category}: {p.description or p.pattern_hash[:20]}")
+    
+    elif args.command == "pending":
+        patterns = client.fetch_pending()
+        if args.json:
+            print(json.dumps([{"id": p.id, "category": p.category, "votes_up": p.votes_up, "votes_down": p.votes_down} for p in patterns], indent=2))
+        else:
+            print(f"⏳ {len(patterns)} patterns pending validation:")
+            for p in patterns[:10]:
+                print(f"   {p.id[:8]}... [{p.category}] 👍{p.votes_up} 👎{p.votes_down}")
+    
+    elif args.command == "report":
+        if not args.pattern:
+            print("❌ --pattern required")
+            exit(1)
+        result = client.report_threat(args.pattern, args.category, args.severity)
+        if result.success:
+            print(f"✅ Reported: {result.pattern_id}")
+        else:
+            print(f"❌ Failed: {result.error}")
+    
+    elif args.command == "vote":
+        if not args.id:
+            print("❌ --id required")
+            exit(1)
+        if not args.approve and not args.reject:
+            print("❌ --approve or --reject required")
+            exit(1)
+        success = client.vote(args.id, args.approve)
+        print("✅ Vote recorded" if success else "❌ Vote failed")

package/skills/proto-persona/SKILL.md

@@ -0,0 +1,336 @@
+---
+name: proto-persona
+description: >-
+  Create an assumption-based persona profile synthesizing user research, market data, and stakeholder knowledge
+  into a working hypothesis about your target user. Use this when starting a new product or feature
+  and you need a lightweight persona to align the team before deep research.
+type: component
+triggers:
+  - "help me create a persona"
+  - "who is our target user"
+  - "build a proto-persona"
+  - "I need a user profile for this feature"
+negative_triggers:
+  - "validate my persona with data"
+  - "run user interviews"
+  - "segment my analytics"
+---
+
+
+## Purpose
+Create an initial, assumption-based persona profile that synthesizes available user research, market data, and stakeholder knowledge into a working hypothesis about your target user. Use this to align teams early in product development, guide initial design decisions, and identify gaps in understanding that require validation through research.
+
+This is not a validated persona—it's a "proto" (prototype) persona that evolves as you learn more. Think of it as a structured placeholder that prevents design-by-committee while acknowledging you don't have all the answers yet.
+
+## Key Concepts
+
+### What is a Proto-Persona?
+A proto-persona is a lightweight, hypothesis-driven persona created from:
+- **Existing research:** User interviews, surveys, analytics (if available)
+- **Market data:** Industry reports, competitor analysis, demographic trends
+- **Stakeholder knowledge:** Sales, support, and team insights
+- **Informed assumptions:** Best guesses that need validation
+
+### Proto vs. Validated Persona
+| Proto-Persona | Validated Persona |
+|---------------|-------------------|
+| Created in hours/days | Created over weeks/months |
+| Based on assumptions + limited research | Based on extensive user research |
+| Used to align teams early | Used to guide detailed design |
+| Evolves rapidly | Stable over time |
+| Good enough to start | High confidence |
+
+### Why Use Proto-Personas?
+- **Speed:** Align teams quickly without waiting for months of research
+- **Focus:** Provides a shared reference point for "who we're building for"
+- **Hypothesis framing:** Makes assumptions explicit, which can then be validated
+- **Prevents generic design:** "Design for everyone" = design for no one
+
+### Anti-Patterns (What This Is NOT)
+- **Not validated research:** Don't treat it as fact—it's a hypothesis
+- **Not a replacement for user research:** Use it to *guide* research, not avoid it
+- **Not demographic data alone:** Age and location don't explain behavior
+- **Not permanent:** Proto-personas should evolve as you learn
+
+### When to Use This
+- Early-stage product development (before extensive user research)
+- Kicking off a new feature or pivot
+- Aligning stakeholders on target users
+- Identifying research gaps (who do we need to interview?)
+
+### When NOT to Use This
+- After you've done extensive user research (create a validated persona instead)
+- For mature products with known user segments (you should already have validated personas)
+- As a substitute for quantitative data (proto-personas inform research; research validates them)
+
+---
+
+## Application
+
+Use `template.md` for the full fill-in structure.
+
+### Step 1: Gather Available Context
+Before creating a proto-persona, collect:
+- **User research:** Interview notes, survey results, support tickets
+- **Analytics:** Usage data, demographics, behavioral patterns
+- **Market data:** Industry reports, competitor user bases
+- **Stakeholder insights:** Sales/support/CS teams who interact with users
+- **Product context:** What problem are you solving? (reference `skills/problem-statement/SKILL.md`)
+
+**If missing context:** Don't fabricate—note gaps and plan research to fill them.
+
+---
+
+### Step 2: Define the Persona's Identity
+
+#### Name
+Give the persona an **alliterative, memorable name** (makes it easier to reference).
+
+```markdown
+### Name
+- [Alliterative name, e.g., "Manager Mike," "Startup Sarah," "Enterprise Emma"]
+```
+
+**Quality checks:**
+- **Memorable:** Can the team recall it easily?
+- **Not generic:** Avoid "User 1" or "Persona A"
+
+---
+
+#### Bio & Demographics
+Describe who this person is in the real world.
+
+```markdown
+### Bio & Demographics
+- [Age range]
+- [Geographic location]
+- [Social status (married, single, family, etc.)]
+- [Online presence (active on LinkedIn, avoids social media, etc.)]
+- [Leisure activities]
+- [Career status (job title, industry, seniority)]
+```
+
+**Quality checks:**
+- **Behavioral, not just demographic:** Don't stop at "30-40 years old, lives in SF"—add "Works remotely, active in Slack communities, juggles 3 side projects"
+- **Context-relevant:** Only include demographics that influence product decisions
+
+**Example:**
+- "35-45 years old, lives in urban areas (NYC, SF, Austin)"
+- "Director-level at mid-sized tech companies (50-500 employees)"
+- "Active on LinkedIn and Twitter, attends 2-3 conferences per year"
+- "Married with young kids, values work-life balance"
+- "Plays rec sports on weekends, listens to business podcasts during commute"
+
+---
+
+### Step 3: Capture Their Voice
+
+#### Quotes
+Use real or representative quotes that reveal how they think and speak.
+
+```markdown
+### Quotes
+- "[Quote 1 revealing what they say, feel, or think]"
+- "[Quote 2 revealing frustrations or motivations]"
+- "[Quote 3 revealing attitudes or beliefs]"
+```
+
+**Quality checks:**
+- **Authentic:** Use real quotes from interviews/support tickets if available
+- **Revealing:** Quotes should expose mindset, not just facts ("I need better tools" is weak; "I'm drowning in manual work and can't focus on strategy" is strong)
+
+**Example:**
+- "I spend 10 hours a week in status meetings that could be emails."
+- "I'm tired of tools that promise automation but require a developer to set up."
+- "My team expects me to have answers immediately, but I'm constantly searching for data."
+
+---
+
+### Step 4: Document Their Context
+
+#### Pains
+What problems or frustrations does this persona experience? (Reference `skills/jobs-to-be-done/SKILL.md` for structure.)
+
+```markdown
+### Pains
+- [Pain point 1 related to the problem space]
+- [Pain point 2 related to the problem space]
+- [Pain point 3 related to the problem space]
+```
+
+**Quality checks:**
+- **Specific:** "Frustrated with tools" is vague; "Spends 3 hours/week manually copying data between tools" is specific
+- **Related to your product:** Focus on pains your product could address
+
+---
+
+#### What is This Person Trying to Accomplish?
+What behaviors, actions, or outcomes are they pursuing?
+
+```markdown
+### What is This Person Trying to Accomplish?
+- [Behavior or outcome 1]
+- [Behavior or outcome 2]
+- [Behavior or outcome 3]
+```
+
+**Quality checks:**
+- **Observable:** Can you see this behavior? ("Get promoted" is internal; "Deliver projects 2 weeks ahead of schedule" is observable)
+- **Outcome-focused:** Not tasks ("use dashboards") but results ("make data-driven decisions faster")
+
+---
+
+#### Goals
+What are their wants, needs, dreams?
+
+```markdown
+### Goals
+- [Goal 1: want, need, or dream]
+- [Goal 2: want, need, or dream]
+- [Goal 3: want, need, or dream]
+```
+
+**Quality checks:**
+- **Short-term and long-term:** Include tactical goals ("ship feature by Q2") and aspirational goals ("become VP within 3 years")
+- **Personal and professional:** "Spend more time with family" can be as relevant as "increase team productivity"
+
+---
+
+### Step 5: Understand Their Influences
+
+#### Decision-Making Authority
+Do they have the power to buy your solution?
+
+```markdown
+### Attitudes & Influences
+
+- **Decision-Making Authority:** [Yes/No + context (e.g., "Has budget authority up to $10k, needs exec approval above that")]
+```
+
+**Quality checks:**
+- **Procurement reality:** If they're a user but not a buyer, note who approves the purchase
+
+---
+
+#### Decision Influencers
+Who influences their decisions?
+
+```markdown
+- **Decision Influencers:** [Who influences this person? (e.g., "Boss, peers in industry Slack channels, analyst reports")]
+```
+
+**Quality checks:**
+- **Specific:** Not just "their manager"—name the types of influences (peer recommendations, Gartner reports, Twitter threads, etc.)
+
+---
+
+#### Beliefs & Attitudes
+What beliefs and attitudes shape their decisions?
+
+```markdown
+- **Beliefs & Attitudes:** [Beliefs/attitudes that impact decisions (e.g., "Skeptical of tools that require training," "Values data-driven decision making")]
+```
+
+**Quality checks:**
+- **Relevant to adoption:** Focus on beliefs that affect whether they'd use your product
+
+---
+
+### Step 6: Validate and Iterate
+
+- **Share with the team:** Does this persona resonate? Do they recognize this person?
+- **Identify gaps:** What don't we know? (Add "[ASSUMPTION—VALIDATE]" tags where uncertain)
+- **Plan research:** Use the proto-persona to guide who to interview next
+- **Evolve it:** As you learn, update the proto-persona (or graduate it to a validated persona)
+
+---
+
+## Examples
+
+See `examples/sample.md` for full proto-persona examples.
+
+Mini example excerpt:
+
+```markdown
+### Name
+- Manager Mike
+
+### Quotes
+- "I spend more time in status meetings than actually building product."
+```
+
+---
+
+## Common Pitfalls
+
+### Pitfall 1: Demographics Without Behavior
+**Symptom:** "28 years old, lives in NYC, has a dog"
+
+**Consequence:** Demographics don't explain *why* someone would use your product.
+
+**Fix:** Add behavioral context: "Works remotely, active in 5 Slack communities, values async communication tools."
+
+---
+
+### Pitfall 2: Treating Proto-Persona as Fact
+**Symptom:** "Manager Mike would never use feature X because he hates complexity"
+
+**Consequence:** You're treating an assumption as validated research.
+
+**Fix:** Add "[ASSUMPTION—VALIDATE]" tags and plan interviews to test hypotheses.
+
+---
+
+### Pitfall 3: Creating 10 Proto-Personas
+**Symptom:** Trying to model every possible user type upfront
+
+**Consequence:** Analysis paralysis. Teams can't focus on a primary user.
+
+**Fix:** Start with 1-2 proto-personas (primary + secondary). Add more as you validate and expand.
+
+---
+
+### Pitfall 4: Fabricating Quotes
+**Symptom:** Quotes that sound like marketing copy: "I love products that delight me!"
+
+**Consequence:** Fake personas lead to fake empathy.
+
+**Fix:** Use real quotes from interviews, support tickets, or sales calls. If you don't have quotes yet, note "[PLACEHOLDER—NEEDS RESEARCH]."
+
+---
+
+### Pitfall 5: Never Validating
+**Symptom:** Proto-persona created 6 months ago, never updated
+
+**Consequence:** You're designing for a hypothesis that may be wrong.
+
+**Fix:** Plan research sprints to validate key assumptions. Evolve the proto-persona as you learn. Graduate it to a validated persona when confidence is high.
+
+---
+
+## References
+
+### Related Skills
+- `skills/problem-statement/SKILL.md` — Persona informs the "I am" section
+- `skills/jobs-to-be-done/SKILL.md` — JTBD informs persona pains/goals
+- `skills/positioning-statement/SKILL.md` — Persona is the "For [target]"
+- `skills/user-story/SKILL.md` — Stories use "As a [persona]"
+
+### External Frameworks
+- Alan Cooper, *The Inmates Are Running the Asylum* (1998) — Origin of persona concept
+- Jeff Gothelf, *Lean UX* (2013) — Proto-personas as hypothesis-driven research tools
+- Indi Young, *Mental Models* (2008) — Behavior-driven persona development
+
+### Dean's Work
+- Proto-Persona Profile Prompt (inspired by Productside Product Manager's Playbook)
+
+### Provenance
+- Adapted from `prompts/proto-persona-profile.md` in the `https://github.com/deanpeters/product-manager-prompts` repo.
+
+---
+
+**Skill type:** Component
+**Suggested filename:** `proto-persona.md`
+**Suggested placement:** `/skills/components/`
+**Dependencies:** References `skills/jobs-to-be-done/SKILL.md`, `skills/problem-statement/SKILL.md`
+**Used by:** `skills/positioning-statement/SKILL.md`, `skills/user-story/SKILL.md`, `skills/problem-statement/SKILL.md`