opencode-skills-collection 1.0.186 → 1.0.187

package/bundled-skills/browser-extension-builder/SKILL.md

@@ -1,13 +1,20 @@
 ---
 name: browser-extension-builder
-description: "You extend the browser to give users superpowers. You understand the unique constraints of extension development - permissions, security, store policies. You build extensions that people install and actually use daily. You know the difference between a toy and a tool."
+description: Expert in building browser extensions that solve real problems -
+  Chrome, Firefox, and cross-browser extensions. Covers extension architecture,
+  manifest v3, content scripts, popup UIs, monetization strategies, and Chrome
+  Web Store publishing.
 risk: unknown
-source: "vibeship-spawner-skills (Apache 2.0)"
-date_added: "2026-02-27"
+source: vibeship-spawner-skills (Apache 2.0)
+date_added: 2026-02-27
 ---
 
 # Browser Extension Builder
 
+Expert in building browser extensions that solve real problems - Chrome, Firefox,
+and cross-browser extensions. Covers extension architecture, manifest v3, content
+scripts, popup UIs, monetization strategies, and Chrome Web Store publishing.
+
 **Role**: Browser Extension Architect
 
 You extend the browser to give users superpowers. You understand the
@@ -15,6 +22,15 @@ unique constraints of extension development - permissions, security,
 store policies. You build extensions that people install and actually
 use daily. You know the difference between a toy and a tool.
 
+### Expertise
+
+- Chrome extension APIs
+- Manifest v3
+- Content scripts
+- Service workers
+- Extension UX
+- Store publishing
+
 ## Capabilities
 
 - Extension architecture
@@ -34,6 +50,8 @@ Structure for modern browser extensions
 
 **When to use**: When starting a new extension
 
+## Extension Architecture
+
 ### Project Structure
 ```
 extension/
@@ -95,6 +113,8 @@ Code that runs on web pages
 
 **When to use**: When modifying or reading page content
 
+## Content Scripts
+
 ### Basic Content Script
 ```javascript
 // content.js - Runs on every matched page
@@ -159,6 +179,8 @@ Persisting extension data
 
 **When to use**: When saving user settings or data
 
+## Storage and State
+
 ### Chrome Storage API
 ```javascript
 // Save data
@@ -208,47 +230,152 @@ const { settings } = await getStorage(['settings']);
 await setStorage({ settings: { ...settings, theme: 'dark' } });
 ```
 
-## Anti-Patterns
+### Extension Monetization
+
+Making money from extensions
+
+**When to use**: When planning extension revenue
+
+## Extension Monetization
+
+### Revenue Models
+| Model | How It Works |
+|-------|--------------|
+| Freemium | Free basic, paid features |
+| One-time | Pay once, use forever |
+| Subscription | Monthly/yearly access |
+| Donations | Tip jar / Buy me a coffee |
+| Affiliate | Recommend products |
+
+### Payment Integration
+```javascript
+// Use your backend for payments
+// Extension can't directly use Stripe
+
+// 1. User clicks "Upgrade" in popup
+// 2. Open your website with user ID
+chrome.tabs.create({
+  url: `https://your-site.com/upgrade?user=${userId}`
+});
+
+// 3. After payment, sync status
+async function checkPremium() {
+  const { userId } = await getStorage(['userId']);
+  const response = await fetch(
+    `https://your-api.com/premium/${userId}`
+  );
+  const { isPremium } = await response.json();
+  await setStorage({ isPremium });
+  return isPremium;
+}
+```
+
+### Feature Gating
+```javascript
+async function usePremiumFeature() {
+  const { isPremium } = await getStorage(['isPremium']);
+  if (!isPremium) {
+    showUpgradeModal();
+    return;
+  }
+  // Run premium feature
+}
+```
+
+### Chrome Web Store Payments
+- Chrome discontinued built-in payments
+- Use your own payment system
+- Link to external checkout page
+
+## Validation Checks
+
+### Using Deprecated Manifest V2
 
-### ❌ Requesting All Permissions
+Severity: HIGH
 
-**Why bad**: Users won't install.
-Store may reject.
-Security risk.
-Bad reviews.
+Message: Using Manifest V2 - Chrome requires V3 for new extensions.
 
-**Instead**: Request minimum needed.
-Use optional permissions.
-Explain why in description.
-Request at time of use.
+Fix action: Migrate to Manifest V3 with service worker
 
-### ❌ Heavy Background Processing
+### Excessive Permissions Requested
 
-**Why bad**: MV3 terminates idle workers.
-Battery drain.
-Browser slows down.
-Users uninstall.
+Severity: HIGH
 
-**Instead**: Keep background minimal.
-Use alarms for periodic tasks.
-Offload to content scripts.
-Cache aggressively.
+Message: Requesting broad permissions - may cause store rejection.
 
-### ❌ Breaking on Updates
+Fix action: Use specific host_permissions and optional_permissions
 
-**Why bad**: Selectors change.
-APIs change.
-Angry users.
-Bad reviews.
+### No Error Handling in Extension
 
-**Instead**: Use stable selectors.
-Add error handling.
-Monitor for breakage.
-Update quickly when broken.
+Severity: MEDIUM
+
+Message: Not checking chrome.runtime.lastError for errors.
+
+Fix action: Check chrome.runtime.lastError after API calls
+
+### Hardcoded URLs in Extension
+
+Severity: MEDIUM
+
+Message: Hardcoded URLs may cause issues in production.
+
+Fix action: Use chrome.storage or manifest for configuration
+
+### Missing Extension Icons
+
+Severity: LOW
+
+Message: Missing extension icons - affects store listing.
+
+Fix action: Add icons in 16, 48, and 128 pixel sizes
+
+## Collaboration
+
+### Delegation Triggers
+
+- react|vue|svelte -> frontend (Extension popup framework)
+- monetization|payment|subscription -> micro-saas-launcher (Extension business model)
+- personal tool|just for me -> personal-tool-builder (Personal extension)
+- AI|LLM|GPT -> ai-wrapper-product (AI-powered extension)
+
+### Productivity Extension
+
+Skills: browser-extension-builder, frontend, micro-saas-launcher
+
+Workflow:
+
+```
+1. Define extension functionality
+2. Build popup UI with React
+3. Implement content scripts
+4. Add premium features
+5. Publish to Chrome Web Store
+6. Market and iterate
+```
+
+### AI Browser Assistant
+
+Skills: browser-extension-builder, ai-wrapper-product, frontend
+
+Workflow:
+
+```
+1. Design AI features for browser
+2. Build extension architecture
+3. Integrate AI API
+4. Create popup interface
+5. Handle usage limits/payments
+6. Publish and grow
+```
 
 ## Related Skills
 
 Works well with: `frontend`, `micro-saas-launcher`, `personal-tool-builder`
 
 ## When to Use
-This skill is applicable to execute the workflow or actions described in the overview.
+
+- User mentions or implies: browser extension
+- User mentions or implies: chrome extension
+- User mentions or implies: firefox addon
+- User mentions or implies: extension
+- User mentions or implies: manifest v3

package/bundled-skills/bullmq-specialist/SKILL.md

@@ -1,23 +1,27 @@
 ---
 name: bullmq-specialist
-description: "BullMQ expert for Redis-backed job queues, background processing, and reliable async execution in Node.js/TypeScript applications. Use when: bullmq, bull queue, redis queue, background job, job queue."
+description: BullMQ expert for Redis-backed job queues, background processing,
+  and reliable async execution in Node.js/TypeScript applications.
 risk: none
-source: "vibeship-spawner-skills (Apache 2.0)"
-date_added: "2026-02-27"
+source: vibeship-spawner-skills (Apache 2.0)
+date_added: 2026-02-27
 ---
 
 # BullMQ Specialist
 
-You are a BullMQ expert who has processed billions of jobs in production.
-You understand that queues are the backbone of scalable applications - they
-decouple services, smooth traffic spikes, and enable reliable async processing.
+BullMQ expert for Redis-backed job queues, background processing, and
+reliable async execution in Node.js/TypeScript applications.
 
-You've debugged stuck jobs at 3am, optimized worker concurrency for maximum
-throughput, and designed job flows that handle complex multi-step processes.
-You know that most queue problems are actually Redis problems or application
-design problems.
+## Principles
 
-Your core philosophy:
+- Jobs are fire-and-forget from the producer side - let the queue handle delivery
+- Always set explicit job options - defaults rarely match your use case
+- Idempotency is your responsibility - jobs may run more than once
+- Backoff strategies prevent thundering herds - exponential beats linear
+- Dead letter queues are not optional - failed jobs need a home
+- Concurrency limits protect downstream services - start conservative
+- Job data should be small - pass IDs, not payloads
+- Graceful shutdown prevents orphaned jobs - handle SIGTERM properly
 
 ## Capabilities
 
@@ -32,31 +36,358 @@ Your core philosophy:
 - flow-producers
 - job-dependencies
 
+## Scope
+
+- redis-infrastructure -> redis-specialist
+- serverless-queues -> upstash-qstash
+- workflow-orchestration -> temporal-craftsman
+- event-sourcing -> event-architect
+- email-delivery -> email-systems
+
+## Tooling
+
+### Core
+
+- bullmq
+- ioredis
+
+### Hosting
+
+- upstash
+- redis-cloud
+- elasticache
+- railway
+
+### Monitoring
+
+- bull-board
+- arena
+- bullmq-pro
+
+### Patterns
+
+- delayed-jobs
+- repeatable-jobs
+- job-flows
+- rate-limiting
+- sandboxed-processors
+
 ## Patterns
 
 ### Basic Queue Setup
 
 Production-ready BullMQ queue with proper configuration
 
+**When to use**: Starting any new queue implementation
+
+import { Queue, Worker, QueueEvents } from 'bullmq';
+import IORedis from 'ioredis';
+
+// Shared connection for all queues
+const connection = new IORedis(process.env.REDIS_URL, {
+  maxRetriesPerRequest: null,  // Required for BullMQ
+  enableReadyCheck: false,
+});
+
+// Create queue with sensible defaults
+const emailQueue = new Queue('emails', {
+  connection,
+  defaultJobOptions: {
+    attempts: 3,
+    backoff: {
+      type: 'exponential',
+      delay: 1000,
+    },
+    removeOnComplete: { count: 1000 },
+    removeOnFail: { count: 5000 },
+  },
+});
+
+// Worker with concurrency limit
+const worker = new Worker('emails', async (job) => {
+  await sendEmail(job.data);
+}, {
+  connection,
+  concurrency: 5,
+  limiter: {
+    max: 100,
+    duration: 60000,  // 100 jobs per minute
+  },
+});
+
+// Handle events
+worker.on('failed', (job, err) => {
+  console.error(`Job ${job?.id} failed:`, err);
+});
+
 ### Delayed and Scheduled Jobs
 
 Jobs that run at specific times or after delays
 
+**When to use**: Scheduling future tasks, reminders, or timed actions
+
+// Delayed job - runs once after delay
+await queue.add('reminder', { userId: 123 }, {
+  delay: 24 * 60 * 60 * 1000,  // 24 hours
+});
+
+// Repeatable job - runs on schedule
+await queue.add('daily-digest', { type: 'summary' }, {
+  repeat: {
+    pattern: '0 9 * * *',  // Every day at 9am
+    tz: 'America/New_York',
+  },
+});
+
+// Remove repeatable job
+await queue.removeRepeatable('daily-digest', {
+  pattern: '0 9 * * *',
+  tz: 'America/New_York',
+});
+
 ### Job Flows and Dependencies
 
 Complex multi-step job processing with parent-child relationships
 
-## Anti-Patterns
+**When to use**: Jobs depend on other jobs completing first
+
+import { FlowProducer } from 'bullmq';
+
+const flowProducer = new FlowProducer({ connection });
+
+// Parent waits for all children to complete
+await flowProducer.add({
+  name: 'process-order',
+  queueName: 'orders',
+  data: { orderId: 123 },
+  children: [
+    {
+      name: 'validate-inventory',
+      queueName: 'inventory',
+      data: { orderId: 123 },
+    },
+    {
+      name: 'charge-payment',
+      queueName: 'payments',
+      data: { orderId: 123 },
+    },
+    {
+      name: 'notify-warehouse',
+      queueName: 'notifications',
+      data: { orderId: 123 },
+    },
+  ],
+});
+
+### Graceful Shutdown
+
+Properly close workers without losing jobs
+
+**When to use**: Deploying or restarting workers
+
+const shutdown = async () => {
+  console.log('Shutting down gracefully...');
+
+  // Stop accepting new jobs
+  await worker.pause();
+
+  // Wait for current jobs to finish (with timeout)
+  await worker.close();
+
+  // Close queue connection
+  await queue.close();
+
+  process.exit(0);
+};
+
+process.on('SIGTERM', shutdown);
+process.on('SIGINT', shutdown);
+
+### Bull Board Dashboard
+
+Visual monitoring for BullMQ queues
+
+**When to use**: Need visibility into queue status and job states
+
+import { createBullBoard } from '@bull-board/api';
+import { BullMQAdapter } from '@bull-board/api/bullMQAdapter';
+import { ExpressAdapter } from '@bull-board/express';
+
+const serverAdapter = new ExpressAdapter();
+serverAdapter.setBasePath('/admin/queues');
+
+createBullBoard({
+  queues: [
+    new BullMQAdapter(emailQueue),
+    new BullMQAdapter(orderQueue),
+  ],
+  serverAdapter,
+});
+
+app.use('/admin/queues', serverAdapter.getRouter());
+
+## Validation Checks
+
+### Redis connection missing maxRetriesPerRequest
+
+Severity: ERROR
+
+BullMQ requires maxRetriesPerRequest null for proper reconnection handling
+
+Message: BullMQ queue/worker created without maxRetriesPerRequest: null on Redis connection. This will cause workers to stop on Redis connection issues.
+
+### No stalled job event handler
+
+Severity: WARNING
+
+Workers should handle stalled events to detect crashed workers
 
-### ❌ Giant Job Payloads
+Message: Worker created without 'stalled' event handler. Stalled jobs indicate worker crashes and should be monitored.
 
-### ❌ No Dead Letter Queue
+### No failed job event handler
 
-### ❌ Infinite Concurrency
+Severity: WARNING
+
+Workers should handle failed events for monitoring and alerting
+
+Message: Worker created without 'failed' event handler. Failed jobs should be logged and monitored.
+
+### No graceful shutdown handling
+
+Severity: WARNING
+
+Workers should gracefully shut down on SIGTERM/SIGINT
+
+Message: Worker file without graceful shutdown handling. Jobs may be orphaned on deployment.
+
+### Awaiting queue.add in request handler
+
+Severity: INFO
+
+Queue additions should be fire-and-forget in request handlers
+
+Message: Queue.add awaited in request handler. Consider fire-and-forget for faster response.
+
+### Potentially large data in job payload
+
+Severity: WARNING
+
+Job data should be small - pass IDs not full objects
+
+Message: Job appears to have large inline data. Pass IDs instead of full objects to keep Redis memory low.
+
+### Job without timeout configuration
+
+Severity: INFO
+
+Jobs should have timeouts to prevent infinite execution
+
+Message: Job added without explicit timeout. Consider adding timeout to prevent stuck jobs.
+
+### Retry without backoff strategy
+
+Severity: WARNING
+
+Retries should use exponential backoff to avoid thundering herd
+
+Message: Job has retry attempts but no backoff strategy. Use exponential backoff to prevent thundering herd.
+
+### Repeatable job without explicit timezone
+
+Severity: WARNING
+
+Repeatable jobs should specify timezone to avoid DST issues
+
+Message: Repeatable job without explicit timezone. Will use server local time which can drift with DST.
+
+### Potentially high worker concurrency
+
+Severity: INFO
+
+High concurrency can overwhelm downstream services
+
+Message: Worker concurrency is high. Ensure downstream services can handle this load (DB connections, API rate limits).
+
+## Collaboration
+
+### Delegation Triggers
+
+- redis infrastructure|redis cluster|memory tuning -> redis-specialist (Queue needs Redis infrastructure)
+- serverless queue|edge queue|no redis -> upstash-qstash (Need queues without managing Redis)
+- complex workflow|saga|compensation|long-running -> temporal-craftsman (Need workflow orchestration beyond simple jobs)
+- event sourcing|CQRS|event streaming -> event-architect (Need event-driven architecture)
+- deploy|kubernetes|scaling|infrastructure -> devops (Queue needs infrastructure)
+- monitor|metrics|alerting|dashboard -> performance-hunter (Queue needs monitoring)
+
+### Email Queue Stack
+
+Skills: bullmq-specialist, email-systems, redis-specialist
+
+Workflow:
+
+```
+1. Email request received (API)
+2. Job queued with rate limiting (bullmq-specialist)
+3. Worker processes with backoff (bullmq-specialist)
+4. Email sent via provider (email-systems)
+5. Status tracked in Redis (redis-specialist)
+```
+
+### Background Processing Stack
+
+Skills: bullmq-specialist, backend, devops
+
+Workflow:
+
+```
+1. API receives request (backend)
+2. Long task queued for background (bullmq-specialist)
+3. Worker processes async (bullmq-specialist)
+4. Result stored/notified (backend)
+5. Workers scaled per load (devops)
+```
+
+### AI Processing Pipeline
+
+Skills: bullmq-specialist, ai-workflow-automation, performance-hunter
+
+Workflow:
+
+```
+1. AI task submitted (ai-workflow-automation)
+2. Job flow created with dependencies (bullmq-specialist)
+3. Workers process stages (bullmq-specialist)
+4. Performance monitored (performance-hunter)
+5. Results aggregated (ai-workflow-automation)
+```
+
+### Scheduled Tasks Stack
+
+Skills: bullmq-specialist, backend, redis-specialist
+
+Workflow:
+
+```
+1. Repeatable jobs defined (bullmq-specialist)
+2. Cron patterns with timezone (bullmq-specialist)
+3. Jobs execute on schedule (bullmq-specialist)
+4. State managed in Redis (redis-specialist)
+5. Results handled (backend)
+```
 
 ## Related Skills
 
 Works well with: `redis-specialist`, `backend`, `nextjs-app-router`, `email-systems`, `ai-workflow-automation`, `performance-hunter`
 
 ## When to Use
-This skill is applicable to execute the workflow or actions described in the overview.
+
+- User mentions or implies: bullmq
+- User mentions or implies: bull queue
+- User mentions or implies: redis queue
+- User mentions or implies: background job
+- User mentions or implies: job queue
+- User mentions or implies: delayed job
+- User mentions or implies: repeatable job
+- User mentions or implies: worker process
+- User mentions or implies: job scheduling
+- User mentions or implies: async processing