@rune-kit/rune 2.3.3 → 2.6.0

package/skills/sentinel/references/auth-crypto-reference.md

@@ -0,0 +1,192 @@
+# Auth & Cryptography Reference
+
+> Loaded by `sentinel` when authentication, password hashing, encryption, or token management patterns detected.
+
+---
+
+## Password Hashing
+
+### Recommended: Argon2id
+
+```javascript
+import { hash, verify } from '@node-rs/argon2';
+
+// Hash — use these parameters minimum
+const hashed = await hash(password, {
+  memoryCost: 65536,    // 64 MB
+  timeCost: 3,          // 3 iterations
+  parallelism: 4,       // 4 threads
+  outputLen: 32,        // 32 bytes
+});
+
+// Verify
+const valid = await verify(hashed, password);
+```
+
+### Acceptable: bcrypt
+
+```javascript
+import bcrypt from 'bcrypt';
+
+const ROUNDS = 12; // minimum 12, never below 10
+const hashed = await bcrypt.hash(password, ROUNDS);
+const valid = await bcrypt.compare(password, hashed);
+```
+
+### Severity Table
+
+| Algorithm | Verdict | Action |
+|-----------|---------|--------|
+| Argon2id | PASS | Preferred |
+| bcrypt (rounds ≥ 12) | PASS | Acceptable |
+| bcrypt (rounds < 10) | WARN | Increase rounds |
+| scrypt | WARN | Prefer Argon2id |
+| SHA-256/SHA-512 + salt | BLOCK | Not a password hash |
+| MD5 / SHA-1 | BLOCK | Broken, must replace |
+| Plaintext | BLOCK | Critical vulnerability |
+
+---
+
+## JWT Best Practices
+
+### Token Lifecycle
+
+```javascript
+// Access token: short-lived (15 min)
+const accessToken = jwt.sign(
+  { sub: user.id, role: user.role },
+  process.env.JWT_SECRET,
+  { expiresIn: '15m', algorithm: 'HS256' }
+);
+
+// Refresh token: longer (7 days), stored in HttpOnly cookie
+const refreshToken = jwt.sign(
+  { sub: user.id, type: 'refresh' },
+  process.env.JWT_REFRESH_SECRET,
+  { expiresIn: '7d' }
+);
+
+res.cookie('refresh_token', refreshToken, {
+  httpOnly: true,     // No JavaScript access
+  secure: true,       // HTTPS only
+  sameSite: 'strict', // No cross-site
+  maxAge: 7 * 24 * 60 * 60 * 1000,
+  path: '/api/auth/refresh', // Only sent to refresh endpoint
+});
+```
+
+### JWT BLOCK Patterns
+
+| Pattern | Severity | Fix |
+|---------|----------|-----|
+| `algorithm: 'none'` | BLOCK | Always specify algorithm |
+| No `expiresIn` | BLOCK | Tokens MUST expire |
+| Secret < 32 chars | WARN | Use 256-bit minimum |
+| JWT in localStorage | WARN | Use HttpOnly cookie for refresh |
+| No audience/issuer validation | WARN | Add `aud` and `iss` claims |
+
+---
+
+## OAuth2 with PKCE
+
+```javascript
+// 1. Generate PKCE challenge
+const codeVerifier = crypto.randomBytes(32).toString('base64url');
+const codeChallenge = crypto
+  .createHash('sha256')
+  .update(codeVerifier)
+  .digest('base64url');
+
+// 2. Authorization URL
+const authUrl = new URL('https://provider.com/authorize');
+authUrl.searchParams.set('response_type', 'code');
+authUrl.searchParams.set('client_id', CLIENT_ID);
+authUrl.searchParams.set('redirect_uri', REDIRECT_URI);
+authUrl.searchParams.set('code_challenge', codeChallenge);
+authUrl.searchParams.set('code_challenge_method', 'S256');
+authUrl.searchParams.set('state', crypto.randomBytes(16).toString('hex'));
+
+// 3. Exchange code (callback) — include code_verifier
+const tokenResponse = await fetch('https://provider.com/token', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+  body: new URLSearchParams({
+    grant_type: 'authorization_code',
+    code: authorizationCode,
+    redirect_uri: REDIRECT_URI,
+    client_id: CLIENT_ID,
+    code_verifier: codeVerifier, // Proves we initiated the flow
+  }),
+});
+```
+
+---
+
+## Encryption (Data at Rest)
+
+### AES-256-GCM (Recommended)
+
+```javascript
+import { createCipheriv, createDecipheriv, randomBytes } from 'crypto';
+
+const ALGORITHM = 'aes-256-gcm';
+const KEY = Buffer.from(process.env.ENCRYPTION_KEY, 'hex'); // 32 bytes
+
+function encrypt(plaintext) {
+  const iv = randomBytes(16);
+  const cipher = createCipheriv(ALGORITHM, KEY, iv);
+  const encrypted = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  // Store: iv + tag + ciphertext (all needed for decryption)
+  return Buffer.concat([iv, tag, encrypted]).toString('base64');
+}
+
+function decrypt(encoded) {
+  const buffer = Buffer.from(encoded, 'base64');
+  const iv = buffer.subarray(0, 16);
+  const tag = buffer.subarray(16, 32);
+  const ciphertext = buffer.subarray(32);
+  const decipher = createDecipheriv(ALGORITHM, KEY, iv);
+  decipher.setAuthTag(tag);
+  return decipher.update(ciphertext) + decipher.final('utf8');
+}
+```
+
+### Crypto Rules
+
+| Use Case | Algorithm | BLOCK If |
+|----------|-----------|----------|
+| Password storage | Argon2id / bcrypt | MD5, SHA-*, plaintext |
+| Data encryption | AES-256-GCM | AES-ECB, DES, RC4 |
+| Integrity check | SHA-256 | MD5, SHA-1 |
+| Signatures | HMAC-SHA256 | Custom MAC |
+| Random tokens | `crypto.randomBytes()` | `Math.random()` |
+| Key derivation | scrypt / HKDF | Simple hash |
+
+---
+
+## Fail-Closed Principle
+
+Errors MUST deny access, never grant it:
+
+```javascript
+// BAD: fail-open — error grants access
+function authorize(user) {
+  try {
+    return checkPermission(user);
+  } catch {
+    return true; // BLOCK: error = access granted
+  }
+}
+
+// GOOD: fail-closed — error denies access
+function authorize(user) {
+  try {
+    return checkPermission(user);
+  } catch {
+    return false; // Error = denied
+  }
+}
+```
+
+**BLOCK pattern**: Any catch/except block that returns `true`, `next()`, or allows continuation on auth/permission check failure.

package/skills/sentinel/references/desktop-security.md

@@ -0,0 +1,201 @@
+# Desktop App Security Reference
+
+> Loaded by `sentinel` when Electron or Tauri project detected (package.json contains `electron`, `@tauri-apps/cli`, or `tauri.conf.json` exists).
+
+---
+
+## Electron Security
+
+### Secure BrowserWindow Config
+
+Every BrowserWindow MUST use:
+
+```javascript
+const win = new BrowserWindow({
+  webPreferences: {
+    contextIsolation: true,      // REQUIRED — separates preload from page
+    nodeIntegration: false,       // REQUIRED — no Node in renderer
+    sandbox: true,                // REQUIRED — OS-level sandbox
+    webSecurity: true,            // REQUIRED — enforce same-origin
+    allowRunningInsecureContent: false,
+    experimentalFeatures: false,
+  }
+});
+```
+
+**BLOCK if any of these are wrong:**
+- `contextIsolation: false` — renderer can access Node APIs
+- `nodeIntegration: true` — XSS = full system compromise
+- `sandbox: false` — no OS isolation
+- `webSecurity: false` — disables same-origin policy
+
+### Preload Script (Minimal Surface)
+
+Expose only specific functions, never blanket APIs:
+
+```javascript
+// preload.js — GOOD: minimal, typed API
+const { contextBridge, ipcRenderer } = require('electron');
+
+contextBridge.exposeInMainWorld('api', {
+  readFile: (path) => ipcRenderer.invoke('fs:read', path),
+  saveFile: (path, data) => ipcRenderer.invoke('fs:save', path, data),
+  // NEVER expose: ipcRenderer.send, ipcRenderer.on, require, process
+});
+```
+
+### IPC Validation
+
+Validate BOTH sender identity and message content:
+
+```javascript
+// main.js — validate IPC
+ipcMain.handle('fs:read', async (event, filePath) => {
+  // 1. Verify sender
+  if (event.senderFrame.url !== 'app://./index.html') {
+    throw new Error('Unauthorized IPC sender');
+  }
+
+  // 2. Validate input
+  const resolved = path.resolve(filePath);
+  if (!resolved.startsWith(ALLOWED_DIR)) {
+    throw new Error('Path traversal blocked');
+  }
+
+  return fs.readFileSync(resolved, 'utf-8');
+});
+```
+
+### Deep Link Validation
+
+```javascript
+// Validate protocol handler input
+app.setAsDefaultProtocolClient('myapp');
+
+app.on('open-url', (event, url) => {
+  event.preventDefault();
+
+  const parsed = new URL(url);
+  const ALLOWED_HOSTS = ['app.example.com'];
+  const ALLOWED_PROTOCOLS = ['myapp:'];
+
+  if (!ALLOWED_PROTOCOLS.includes(parsed.protocol)) return;
+  if (parsed.host && !ALLOWED_HOSTS.includes(parsed.host)) return;
+  if (url.length > 2048) return; // Length limit
+
+  handleDeepLink(parsed);
+});
+```
+
+### Electron Vulnerability Checklist
+
+| Check | BLOCK if |
+|-------|----------|
+| `nodeIntegration` | `true` in any window |
+| `contextIsolation` | `false` in any window |
+| `sandbox` | `false` in any window |
+| `webSecurity` | `false` |
+| Preload exposes `ipcRenderer.send` | Direct IPC channel exposed |
+| IPC handler missing sender check | No `event.senderFrame` validation |
+| `shell.openExternal` unvalidated | User-controlled URLs passed directly |
+| Auto-updater over HTTP | Not using HTTPS or missing signature check |
+| `webview` tag without sandbox | Embedded content without isolation |
+| Deep links unvalidated | No protocol/host allowlist |
+
+---
+
+## Tauri Security
+
+### Command Security
+
+```rust
+// GOOD: Strict typing + validation
+#[tauri::command]
+fn read_file(path: String) -> Result<String, String> {
+    let canonical = std::fs::canonicalize(&path)
+        .map_err(|e| e.to_string())?;
+
+    // Validate path is within allowed directory
+    if !canonical.starts_with("/allowed/dir") {
+        return Err("Access denied".into());
+    }
+
+    std::fs::read_to_string(canonical)
+        .map_err(|e| e.to_string())
+}
+```
+
+### Scope Configuration
+
+```json
+// tauri.conf.json — restrictive scopes
+{
+  "tauri": {
+    "allowlist": {
+      "fs": {
+        "scope": ["$APPDATA/*", "$RESOURCE/*"],
+        "readFile": true,
+        "writeFile": true
+      },
+      "http": {
+        "scope": ["https://api.example.com/*"]
+      },
+      "shell": {
+        "open": true,
+        "scope": []
+      }
+    }
+  }
+}
+```
+
+**BLOCK if:**
+- `fs.scope: ["**"]` — unrestricted filesystem access
+- `http.scope: ["https://**"]` — any HTTPS target
+- `shell.scope` contains executable paths without validation
+
+### Tauri Vulnerability Checklist
+
+| Check | BLOCK if |
+|-------|----------|
+| `fs.scope` | Contains `**` or `/` (unrestricted) |
+| `http.scope` | Broad wildcard allowing arbitrary hosts |
+| `shell` commands | Unrestricted `execute` scope |
+| CSP missing | No Content-Security-Policy in `tauri.conf.json` |
+| `invoke()` handler | Missing input validation or type checking |
+
+---
+
+## Common Desktop Patterns
+
+### Code Signing
+
+Always sign releases — unsigned apps trigger OS warnings and can be tampered with:
+
+- **Windows**: EV code signing certificate (hardware token)
+- **macOS**: Developer ID certificate + notarization (`xcrun notarytool`)
+- **Linux**: GPG signing for packages
+
+### Secure Auto-Update
+
+```
+1. Check for update over HTTPS
+2. Verify digital signature of update package
+3. Verify SHA-256 checksum
+4. Prompt user before installing (never silent)
+5. Graceful fallback if update fails
+```
+
+### Credential Storage
+
+```javascript
+// Electron — use safeStorage (OS keychain)
+const { safeStorage } = require('electron');
+
+if (safeStorage.isEncryptionAvailable()) {
+  const encrypted = safeStorage.encryptString(token);
+  // Store encrypted buffer, never plaintext
+}
+```
+
+**BLOCK**: Storing credentials in `localStorage`, plain files, or `electron-store` without encryption.

package/skills/sentinel/references/supply-chain.md

@@ -0,0 +1,160 @@
+# Supply Chain Security Reference
+
+> Loaded by `sentinel` when dependency changes detected (package.json, package-lock.json, requirements.txt, Cargo.toml modified).
+
+---
+
+## Dependency Audit
+
+### Required Checks
+
+On every dependency change, verify:
+
+```bash
+# Node.js
+npm audit --audit-level=high
+npm audit signatures  # Verify registry signatures
+
+# Python
+pip-audit
+safety check
+
+# Rust
+cargo audit
+```
+
+**BLOCK**: Any `high` or `critical` severity vulnerability in direct dependencies.
+**WARN**: `high`/`critical` in transitive dependencies.
+
+---
+
+## Lock File Rules
+
+| Rule | Severity |
+|------|----------|
+| Lock file not committed | BLOCK |
+| Lock file deleted | BLOCK |
+| Lock file modified without package.json change | WARN (investigate) |
+| Multiple lock files (package-lock + yarn.lock) | WARN |
+
+Lock files pin exact versions. Without them, builds are non-reproducible and vulnerable to supply chain attacks.
+
+---
+
+## Typosquatting Prevention
+
+Before adding ANY new dependency, check:
+
+| Signal | Example | Risk |
+|--------|---------|------|
+| Name differs by 1 char | `lodsh` vs `lodash` | Typosquat |
+| Extra hyphen/underscore | `react-domm` | Typosquat |
+| Scoped look-alike | `@react/core` vs `react` | Impersonation |
+| Very new package | Published < 7 days ago | Suspicious |
+| Low download count | < 100 weekly downloads | Unvetted |
+| No repository URL | Missing `repository` field | Cannot verify source |
+
+### Scan Pattern
+
+```javascript
+// sentinel should flag new dependencies added to package.json
+// Check against known package names for close matches
+const KNOWN_PACKAGES = ['lodash', 'express', 'react', 'axios', ...];
+
+function checkTyposquat(name) {
+  for (const known of KNOWN_PACKAGES) {
+    if (levenshteinDistance(name, known) === 1) {
+      return { risk: 'HIGH', similar: known };
+    }
+  }
+}
+```
+
+---
+
+## Version Pinning Strategy
+
+| Dependency Type | Strategy | Why |
+|----------------|----------|-----|
+| Direct (production) | `^` semver (default) | Balance updates + stability |
+| Security-critical | Exact pin (`1.2.3`) | Prevent unexpected changes |
+| Dev tools | `^` semver | Less risk, want updates |
+| CDN resources | SRI hash required | Tamper detection |
+
+### Subresource Integrity (SRI)
+
+For any CDN-loaded script or stylesheet:
+
+```html
+<!-- GOOD: SRI hash verifies integrity -->
+<script
+  src="https://cdn.example.com/lib.js"
+  integrity="sha384-abc123..."
+  crossorigin="anonymous"
+></script>
+
+<!-- BLOCK: CDN resource without SRI -->
+<script src="https://cdn.example.com/lib.js"></script>
+```
+
+---
+
+## npm Security Hardening
+
+| Practice | Priority |
+|----------|----------|
+| Enable 2FA on npm account | BLOCK (maintainers) |
+| Use scoped packages (`@org/pkg`) | Recommended |
+| `npm audit` in CI pipeline | Required |
+| `npm audit signatures` | Recommended |
+| Review `postinstall` scripts | Required for new deps |
+| Use `--ignore-scripts` for untrusted packages | Recommended |
+
+### Dangerous Install Scripts
+
+**WARN** when a newly added package has `postinstall`, `preinstall`, or `install` scripts:
+
+```json
+// package.json of dependency — review these carefully
+{
+  "scripts": {
+    "postinstall": "node setup.js"  // What does this run?
+  }
+}
+```
+
+---
+
+## Automated Dependency Updates
+
+Configure one of:
+
+```yaml
+# .github/dependabot.yml
+version: 2
+updates:
+  - package-ecosystem: npm
+    directory: /
+    schedule:
+      interval: weekly
+    open-pull-requests-limit: 10
+    reviewers:
+      - security-team
+```
+
+**WARN** if no automated dependency update tool is configured (Dependabot, Renovate, or Snyk).
+
+---
+
+## Security Checklist for New Dependencies
+
+Before approving a new dependency:
+
+- [ ] Package name is correct (not a typosquat)
+- [ ] Has significant download count (>1K/week for niche, >10K for common)
+- [ ] Repository URL exists and matches claimed source
+- [ ] No known vulnerabilities (`npm audit`)
+- [ ] License is compatible
+- [ ] Install scripts reviewed (if any)
+- [ ] Maintainer has 2FA enabled (check npm profile)
+- [ ] Not abandoned (last publish < 12 months)

package/skills/session-bridge/SKILL.md

@@ -8,6 +8,7 @@ metadata:
   model: haiku
   group: state
   tools: "Read, Write, Edit, Glob, Grep"
+  listen: phase.complete
 ---
 
 # session-bridge

package/skills/slides/SKILL.md

@@ -0,0 +1,142 @@
+---
+name: slides
+description: Generate Marp-compatible slide decks from structured JSON schema. Converts context into presentations for tech talks, sprint demos, and tutorials.
+metadata:
+  author: runedev
+  version: "0.1.0"
+  layer: L3
+  model: sonnet
+  group: media
+  tools: "Read, Write, Bash"
+---
+
+# slides
+
+## Purpose
+
+Generates structured slide decks as Marp-compatible markdown. The agent analyzes context (feature, sprint, tutorial) and produces a JSON slide schema, then calls `build-deck.js` to convert it to presentation-ready markdown. The script standardizes output format — preventing agent freestyle errors when context runs low.
+
+## Triggers
+
+- User says "create slides", "make presentation", "demo deck", "sprint review slides", "tech talk"
+- `/rune slides` — manual invocation
+- Called by other skills needing presentation output
+
+## Called By (inbound)
+
+- `marketing` (L2): launch presentations, product demos
+- `video-creator` (L3): slide-based video storyboards
+- User: direct invocation
+
+## Calls (outbound)
+
+None — pure L3 utility.
+
+## Executable Instructions
+
+### Step 1: Analyze Context
+
+Determine the presentation type from the user's request:
+
+| Context | Template | Typical Slides |
+|---------|----------|---------------|
+| Feature demo | Demo walkthrough | Problem → Solution → Architecture → Live demo → Next steps |
+| Sprint review | Sprint summary | Goals → Completed → Metrics → Blockers → Next sprint |
+| Tech talk | Teaching format | Hook → Concept → Deep dive → Code examples → Takeaways |
+| Tutorial | Step-by-step | Intro → Prerequisites → Step 1-N → Summary → Resources |
+| Pitch | Persuasion | Problem → Market → Solution → Traction → Ask |
+
+### Step 2: Generate JSON Schema
+
+Create a JSON file following this schema:
+
+```json
+{
+  "title": "Presentation Title",
+  "author": "Author Name (optional)",
+  "theme": "default|gaia|uncover",
+  "slides": [
+    {
+      "type": "title|content|code|diagram|image|quote|section",
+      "heading": "Slide Heading",
+      "body": "Markdown body text",
+      "notes": "Speaker notes (optional)",
+      "code": { "lang": "javascript", "source": "console.log('hi')" },
+      "diagram": "graph LR; A-->B"
+    }
+  ]
+}
+```
+
+**Slide types:**
+- `title` — opening slide with `# heading`
+- `content` — standard slide with `## heading` + body
+- `code` — slide with syntax-highlighted code block
+- `diagram` — slide with Mermaid diagram
+- `image` — slide with image reference in body
+- `quote` — slide with blockquote formatting
+- `section` — section divider with `# heading`
+
+Save the JSON to a temporary file (e.g., `slides.json`).
+
+### Step 3: Build Deck
+
+Execute the build script:
+
+```bash
+node {scripts_dir}/build-deck.js --input slides.json --output deck.md
+```
+
+The script outputs Marp-compatible markdown with:
+- Marp frontmatter (`marp: true`, theme)
+- Slide separators (`---`)
+- Speaker notes as HTML comments
+- Code blocks with language hints
+- Mermaid diagram blocks
+
+### Step 4: Present Result
+
+Show the user:
+1. The generated `deck.md` file path
+2. How to preview: `npx @marp-team/marp-cli deck.md --preview` (or any Marp viewer)
+3. How to export PDF: `npx @marp-team/marp-cli deck.md --pdf`
+
+**Fallback**: If `{scripts_dir}/build-deck.js` is unavailable, generate the Marp markdown directly — the script is an optimization, not a hard dependency.
+
+## Output Format
+
+```markdown
+---
+marp: true
+theme: default
+---
+
+# Presentation Title
+
+Author Name
+
+---
+
+## Slide Heading
+
+Slide body content
+
+<!-- notes: Speaker notes here -->
+```
+
+## Sharp Edges
+
+| Failure Mode | Severity | Mitigation |
+|---|---|---|
+| build-deck.js not found | LOW | Agent generates Marp markdown directly (fallback) |
+| Invalid JSON input | MEDIUM | Script exits 1 with parse error — agent fixes JSON and retries |
+| Marp not installed | LOW | Script outputs plain .md — user installs Marp CLI separately |
+| Too many slides (>30) | MEDIUM | Agent should split into multiple decks or summarize |
+
+## Constraints
+
+1. Output MUST be valid Marp markdown (parseable by `@marp-team/marp-cli`)
+2. DO NOT embed build-deck.js source in this skill — call it via `{scripts_dir}`
+3. DO NOT require Marp installation — output is standard markdown that Marp can consume
+4. Keep slide count reasonable (5-15 for demos, 10-25 for talks)
+5. Always include speaker notes for non-trivial slides