remofirst-common-errors SKILL.md View full skill →

Diagnose and fix RemoFirst common errors and exceptions.

ReadGrepBash(curl:*)

remofirst-core-workflow-a SKILL.md View full skill →

Execute RemoFirst primary workflow: Core Workflow A.

ReadWriteEditBash(npm:*)Grep

remofirst-core-workflow-b SKILL.md View full skill →

Execute RemoFirst secondary workflow: Core Workflow B.

ReadWriteEditBash(npm:*)Grep

remofirst-debug-bundle SKILL.md View full skill →

Collect RemoFirst debug evidence for support tickets and troubleshooting.

ReadBash(grep:*)Bash(curl:*)Bash(tar:*)Grep

RemoFirst Debug Bundle

Overview

Collect all necessary diagnostic information for RemoFirst support tickets.

Prerequisites

RemoFirst SDK installed
Access to application logs
Permission to collect environment info

Instructions

Step 1: Create Debug Bundle Script


#!/bin/bash
# remofirst-debug-bundle.sh

BUNDLE_DIR="remofirst-debug-$(date +%Y%m%d-%H%M%S)"
mkdir -p "$BUNDLE_DIR"

echo "=== RemoFirst Debug Bundle ===" > "$BUNDLE_DIR/summary.txt"
echo "Generated: $(date)" >> "$BUNDLE_DIR/summary.txt"

Step 2: Collect Environment Info


# Environment info
echo "--- Environment ---" >> "$BUNDLE_DIR/summary.txt"
node --version >> "$BUNDLE_DIR/summary.txt" 2>&1
npm --version >> "$BUNDLE_DIR/summary.txt" 2>&1
echo "REMOFIRST_API_KEY: ${REMOFIRST_API_KEY:+[SET]}" >> "$BUNDLE_DIR/summary.txt"

Step 3: Gather SDK and Logs


# SDK version
npm list @remofirst/sdk 2>/dev/null >> "$BUNDLE_DIR/summary.txt"

# Recent logs (redacted)
grep -i "remofirst" ~/.npm/_logs/*.log 2>/dev/null | tail -50 >> "$BUNDLE_DIR/logs.txt"

# Configuration (redacted - secrets masked)
echo "--- Config (redacted) ---" >> "$BUNDLE_DIR/summary.txt"
cat .env 2>/dev/null | sed 's/=.*/=***REDACTED***/' >> "$BUNDLE_DIR/config-redacted.txt"

# Network connectivity test
echo "--- Network Test ---" >> "$BUNDLE_DIR/summary.txt"
echo -n "API Health: " >> "$BUNDLE_DIR/summary.txt"
curl -s -o /dev/null -w "%{http_code}" https://api.remofirst.com/health >> "$BUNDLE_DIR/summary.txt"
echo "" >> "$BUNDLE_DIR/summary.txt"

Step 4: Package Bundle


tar -czf "$BUNDLE_DIR.tar.gz" "$BUNDLE_DIR"
echo "Bundle created: $BUNDLE_DIR.tar.gz"

Output

remofirst-debug-YYYYMMDD-HHMMSS.tar.gz archive containing:
summary.txt - Environment and SDK info
logs.txt - Recent redacted logs
config-redacted.txt - Configuration (secrets removed)

Error Handling

remofirst-hello-world SKILL.md View full skill →

Create a minimal working RemoFirst example.

ReadWriteEdit

Item	Purpose	Included
Environment versions	Compatibility check	✓
SDK version	Version-specific bugs	✓
Error logs (redacted)	Root cause analysis	✓
Config (redacted)	Configuration issues	✓

Error	Cause	Solution
Import Error	SDK not installed	Verify with `npm list` or `pip show`
Auth Error	Invalid credentials	Check environment variable is set
Timeout	Network issues	Increase timeout or check connectivity
Rate Limit	Too many requests	Wait and retry with exponential backoff

Examples

TypeScript Example


import { RemoFirstClient } from '@remofirst/sdk';

const client = new RemoFirstClient({
  apiKey: process.env.REMOFIRST_API_KEY,
});

async function main() {
  // Your first API call here
}

main().catch(console.error);

Python Example


from remofirst import RemoFirstClient

client = RemoFirstClient()

# Your first API call here

Resources

Next Steps

Proceed to remofirst-local-dev-loop for development workflow setup.

remofirst-install-auth SKILL.md View full skill →

Install and configure RemoFirst SDK/CLI authentication.

ReadWriteEditBash(npm:*)Bash(pip:*)Grep

remofirst-local-dev-loop SKILL.md View full skill →

Configure RemoFirst local development with hot reload and testing.

ReadWriteEditBash(npm:*)Bash(pnpm:*)Grep

RemoFirst Local Dev Loop

Overview

Set up a fast, reproducible local development workflow for RemoFirst.

Prerequisites

Completed remofirst-install-auth setup
Node.js 18+ with npm/pnpm
Code editor with TypeScript support
Git for version control

Instructions

Step 1: Create Project Structure


my-remofirst-project/
├── src/
│   ├── remofirst/
│   │   ├── client.ts       # RemoFirst client wrapper
│   │   ├── config.ts       # Configuration management
│   │   └── utils.ts        # Helper functions
│   └── index.ts
├── tests/
│   └── remofirst.test.ts
├── .env.local              # Local secrets (git-ignored)
├── .env.example            # Template for team
└── package.json

Step 2: Configure Environment


# Copy environment template
cp .env.example .env.local

# Install dependencies
npm install

# Start development server
npm run dev

Step 3: Setup Hot Reload


{
  "scripts": {
    "dev": "tsx watch src/index.ts",
    "test": "vitest",
    "test:watch": "vitest --watch"
  }
}

Step 4: Configure Testing


import { describe, it, expect, vi } from 'vitest';
import { RemoFirstClient } from '../src/remofirst/client';

describe('RemoFirst Client', () => {
  it('should initialize with API key', () => {
    const client = new RemoFirstClient({ apiKey: 'test-key' });
    expect(client).toBeDefined();
  });
});

Output

Working development environment with hot reload
Configured test suite with mocking
Environment variable management
Fast iteration cycle for RemoFirst development

Error Handling

Error	Cause	Solution
Module not found	Missing dependency	Run `npm install`
Port in use	Another process	Kill process or change port
Env not loaded	Missing .env.local	Copy from .env.example
Test timeout	Slow network	Increase test timeout

Examples

Mock RemoFirst Responses


vi.mock('@remofirst/sdk', () => ({
  RemoFirstClient: vi.fn().mockImplementation(() => ({
    // Mock methods here
  })),
}));

Debug Mode


# Enable verbose logging
DEBUG=REMOFIRST=* npm run dev

Resources

RemoFirst SDK Reference
Vitest Documentation
remofirst-prod-checklist SKILL.md View full skill →

Execute RemoFirst production deployment checklist and rollback procedures.

ReadBash(kubectl:*)Bash(curl:*)Grep
RemoFirst Production Checklist

Overview

Complete checklist for deploying RemoFirst integrations to production.

Prerequisites
- Staging environment tested and verified
- Production API keys available
- Deployment pipeline configured
- Monitoring and alerting ready
Instructions

Step 1: Pre-Deployment Configuration
- [ ] Production API keys in secure vault
- [ ] Environment variables set in deployment platform
- [ ] API key scopes are minimal (least privilege)
- [ ] Webhook endpoints configured with HTTPS
- [ ] Webhook secrets stored securely
Step 2: Code Quality Verification
- [ ] All tests passing (npm test)
- [ ] No hardcoded credentials
- [ ] Error handling covers all RemoFirst error types
- [ ] Rate limiting/backoff implemented
- [ ] Logging is production-appropriate
Step 3: Infrastructure Setup
- [ ] Health check endpoint includes RemoFirst connectivity
- [ ] Monitoring/alerting configured
- [ ] Circuit breaker pattern implemented
- [ ] Graceful degradation configured
Step 4: Documentation Requirements
- [ ] Incident runbook created
- [ ] Key rotation procedure documented
- [ ] Rollback procedure documented
- [ ] On-call escalation path defined
Step 5: Deploy with Gradual Rollout
```
# Pre-flight checks
curl -f https://staging.example.com/health
curl -s https://status.remofirst.com

# Gradual rollout - start with canary (10%)
kubectl apply -f k8s/production.yaml
kubectl set image deployment/remofirst-integration app=image:new --record
kubectl rollout pause deployment/remofirst-integration

# Monitor canary traffic for 10 minutes
sleep 600
# Check error rates and latency before continuing

# If healthy, continue rollout to 50%
kubectl rollout resume deployment/remofirst-integration
kubectl rollout pause deployment/remofirst-integration
sleep 300

# Complete rollout to 100%
kubectl rollout resume deployment/remofirst-integration
kubectl rollout status deployment/remofirst-integration
```
Output
- Deployed RemoFirst integration
- Health checks passing
- Monitoring active
- Rollback procedure documented
Error Handling

Alert Condition Severity

API Down 5xx errors > 10/min P1

High Latency p99 > 5000ms P2

Rate Limited 429 errors > 5/min P2

Auth Failures 401/403 errors > 0 P1

Examples

Health Check Implementation
```
async function healthCheck(): Promise<{ status: string; rem
```


                
                  
                  
                  remofirst-rate-limits
                  SKILL.md
                  View full skill →
                
                
                  Implement RemoFirst rate limiting, backoff, and idempotency patterns.
                  
                      ReadWriteEdit
                    
                
                
                  RemoFirst Rate Limits
Overview
Handle RemoFirst rate limits gracefully with exponential backoff and idempotency.
Prerequisites

RemoFirst SDK installed
Understanding of async/await patterns
Access to rate limit headers

Instructions
Step 1: Understand Rate Limit Tiers

Tier
Requests/min
Requests/day
Burst


Free
60
1,000
10


Pro
300
10,000
50


Enterprise
1,000
100,000
200


Step 2: Implement Exponential Backoff with Jitter

async function withExponentialBackoff<T>(
  operation: () => Promise<T>,
  config = { maxRetries: 5, baseDelayMs: 1000, maxDelayMs: 32000, jitterMs: 500 }
): Promise<T> {
  for (let attempt = 0; attempt <= config.maxRetries; attempt++) {
    try {
      return await operation();
    } catch (error: any) {
      if (attempt === config.maxRetries) throw error;
      const status = error.status || error.response?.status;
      if (status !== 429 && (status < 500 || status >= 600)) throw error;

      // Exponential delay with jitter to prevent thundering herd
      const exponentialDelay = config.baseDelayMs * Math.pow(2, attempt);
      const jitter = Math.random() * config.jitterMs;
      const delay = Math.min(exponentialDelay + jitter, config.maxDelayMs);

      console.log(`Rate limited. Retrying in ${delay.toFixed(0)}ms...`);
      await new Promise(r => setTimeout(r, delay));
    }
  }
  throw new Error('Unreachable');
}

Step 3: Add Idempotency Keys

import { v4 as uuidv4 } from 'uuid';
import crypto from 'crypto';

// Generate deterministic key from operation params (for safe retries)
function generateIdempotencyKey(operation: string, params: Record<string, any>): string {
  const data = JSON.stringify({ operation, params });
  return crypto.createHash('sha256').update(data).digest('hex');
}

async function idempotentRequest<T>(
  client: RemoFirstClient,
  params: Record<string, any>,
  idempotencyKey?: string  // Pass existing key for retries
): Promise<T> {
  // Use provided key (for retries) or generate deterministic key from params
  const key = idempotencyKey || generateIdempotencyKey(params.method || 'POST', params);
  return client.request({
    ...params,
    headers: { 'Idempotency-Key': key, ...params.headers },
  });
}

Output

Reliable API calls with automatic retry
Idempotent requests preventing duplicates
Rate limit headers properly handled

Error Handling

Header
Description

                
              
                
                  
                  
                  remofirst-sdk-patterns
                  SKILL.md
                  View full skill →
                
                
                  Apply production-ready RemoFirst SDK patterns for TypeScript and Python.
                  
                      ReadWriteEdit
                    
                
                
                  RemoFirst SDK Patterns
Overview
Production-ready patterns for RemoFirst SDK usage in TypeScript and Python.
Prerequisites

Completed remofirst-install-auth setup
Familiarity with async/await patterns
Understanding of error handling best practices

Instructions
Step 1: Implement Singleton Pattern (Recommended)

// src/remofirst/client.ts
import { RemoFirstClient } from '@remofirst/sdk';

let instance: RemoFirstClient | null = null;

export function getRemoFirstClient(): RemoFirstClient {
  if (!instance) {
    instance = new RemoFirstClient({
      apiKey: process.env.REMOFIRST_API_KEY!,
      // Additional options
    });
  }
  return instance;
}

Step 2: Add Error Handling Wrapper

import { RemoFirstError } from '@remofirst/sdk';

async function safeRemoFirstCall<T>(
  operation: () => Promise<T>
): Promise<{ data: T | null; error: Error | null }> {
  try {
    const data = await operation();
    return { data, error: null };
  } catch (err) {
    if (err instanceof RemoFirstError) {
      console.error({
        code: err.code,
        message: err.message,
      });
    }
    return { data: null, error: err as Error };
  }
}

Step 3: Implement Retry Logic

async function withRetry<T>(
  operation: () => Promise<T>,
  maxRetries = 3,
  backoffMs = 1000
): Promise<T> {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      return await operation();
    } catch (err) {
      if (attempt === maxRetries) throw err;
      const delay = backoffMs * Math.pow(2, attempt - 1);
      await new Promise(r => setTimeout(r, delay));
    }
  }
  throw new Error('Unreachable');
}

Output

Type-safe client singleton
Robust error handling with structured logging
Automatic retry with exponential backoff
Runtime validation for API responses

Error Handling

Pattern
Use Case
Benefit


Safe wrapper
All API calls
Prevents uncaught exceptions


Retry logic
Transient failures
Improves reliability


Type guards
Response validation
Catches API changes


Logging
All operations
Debugging and monitoring


Examples
Factory Pattern (Multi-tenant)

const clients = new Map<string, RemoFirstClient>();

export function getClientForTenant(tenantId: string): RemoFirstClient {
  if (!clients.has(tenantId)) {
    const apiKey = getTenantApiKey(tenantId);
    clients.set(tenantId, new RemoFirstClien

                

              

                
                  
                  
                  remofirst-security-basics
                  SKILL.md
                  View full skill →
                
                
                  Apply RemoFirst security best practices for secrets and access control.
                  
                      ReadWriteGrep
                    
                
                
                  RemoFirst Security Basics
Overview
Security best practices for RemoFirst API keys, tokens, and access control.
Prerequisites

RemoFirst SDK installed
Understanding of environment variables
Access to RemoFirst dashboard

Instructions
Step 1: Configure Environment Variables

# .env (NEVER commit to git)
REMOFIRST_API_KEY=sk_live_***
REMOFIRST_SECRET=***

# .gitignore
.env
.env.local
.env.*.local

Step 2: Implement Secret Rotation

# 1. Generate new key in RemoFirst dashboard
# 2. Update environment variable
export REMOFIRST_API_KEY="new_key_here"

# 3. Verify new key works
curl -H "Authorization: Bearer ${REMOFIRST_API_KEY}" \
  https://api.remofirst.com/health

# 4. Revoke old key in dashboard

Step 3: Apply Least Privilege

Environment
Recommended Scopes


Development
read:*


Staging
read:*, write:limited


Production
Only required scopes


Output

Secure API key storage
Environment-specific access controls
Audit logging enabled

Error Handling

Security Issue
Detection
Mitigation


Exposed API key
Git scanning
Rotate immediately


Excessive scopes
Audit logs
Reduce permissions


Missing rotation
Key age check
Schedule rotation


Examples
Service Account Pattern

const clients = {
  reader: new RemoFirstClient({
    apiKey: process.env.REMOFIRST_READ_KEY,
  }),
  writer: new RemoFirstClient({
    apiKey: process.env.REMOFIRST_WRITE_KEY,
  }),
};

Webhook Signature Verification

import crypto from 'crypto';

function verifyWebhookSignature(
  payload: string, signature: string, secret: string
): boolean {
  const expected = crypto.createHmac('sha256', secret).update(payload).digest('hex');
  return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expected));
}

Security Checklist

[ ] API keys in environment variables
[ ] .env files in .gitignore
[ ] Different keys for dev/staging/prod
[ ] Minimal scopes per environment
[ ] Webhook signatures validated
[ ] Audit logging enabled

Audit Logging

interface AuditEntry {
  timestamp: Date;
  action: string;
  userId: string;
  resource: string;
  result: 'success' | 'f

                

              

                
                  
                  
                  remofirst-upgrade-migration
                  SKILL.md
                  View full skill →
                
                
                  Analyze, plan, and execute RemoFirst SDK upgrades with breaking change detection.
                  
                      ReadWriteEditBash(npm:*)Bash(git:*)
                    
                
                
                  RemoFirst Upgrade & Migration
Overview
Guide for upgrading RemoFirst SDK versions and handling breaking changes.
Prerequisites

Current RemoFirst SDK installed
Git for version control
Test suite available
Staging environment

Instructions
Step 1: Check Current Version

npm list @remofirst/sdk
npm view @remofirst/sdk version

Step 2: Review Changelog

open https://github.com/remofirst/sdk/releases

Step 3: Create Upgrade Branch

git checkout -b upgrade/remofirst-sdk-vX.Y.Z
npm install @remofirst/sdk@latest
npm test

Step 4: Handle Breaking Changes
Update import statements, configuration, and method signatures as needed.
Output

Updated SDK version
Fixed breaking changes
Passing test suite
Documented rollback procedure

Error Handling

SDK Version
API Version
Node.js
Breaking Changes


3.x
2024-01
18+
Major refactor


2.x
2023-06
16+
Auth changes


1.x
2022-01
14+
Initial release


Examples
Import Changes

// Before (v1.x)
import { Client } from '@remofirst/sdk';

// After (v2.x)
import { RemoFirstClient } from '@remofirst/sdk';

Configuration Changes

// Before (v1.x)
const client = new Client({ key: 'xxx' });

// After (v2.x)
const client = new RemoFirstClient({
  apiKey: 'xxx',
});

Rollback Procedure

npm install @remofirst/sdk@1.x.x --save-exact

Deprecation Handling

// Monitor for deprecation warnings in development
if (process.env.NODE_ENV === 'development') {
  process.on('warning', (warning) => {
    if (warning.name === 'DeprecationWarning') {
      console.warn('[RemoFirst]', warning.message);
      // Log to tracking system for proactive updates
    }
  });
}

// Common deprecation patterns to watch for:
// - Renamed methods: client.oldMethod() -> client.newMethod()
// - Changed parameters: { key: 'x' } -> { apiKey: 'x' }
// - Removed features: Check release notes before upgrading

Resources

RemoFirst Changelog
RemoFirst Migration Guide

Next Steps
For CI integration during upgrades, see remofirst-ci-integration.
                
              

          
        

      
      

      
      

      
      

      
      
  Ready to use remofirst-pack?
  
    
    
  




      
      
          Related Plugins
          
            
                excel-analyst-pro
                Professional financial modeling toolkit for Claude Code with auto-invoked Skills and Excel MCP integration. Build DCF models, LBO analysis, variance reports, and pivot tables using natural language.
              
                brand-strategy-framework
                A 7-part brand strategy framework for building comprehensive brand foundations - the same methodology top agencies use with Fortune 500 clients.
              
                clay-pack
                Complete Clay integration skill pack with 30 skills covering data enrichment, waterfall workflows, AI agents, and GTM automation. Flagship+ tier vendor pack.
              
                instantly-pack
                Complete Instantly integration skill pack with 24 skills covering cold email, outreach automation, and lead generation. Flagship tier vendor pack.
              
                apollo-pack
                Complete Apollo integration skill pack with 24 skills covering sales engagement, prospecting, sequencing, analytics, and outbound automation. Flagship tier vendor pack.
              
                juicebox-pack
                Complete Juicebox integration skill pack with 24 skills covering people data, enrichment, contact search, and AI-powered discovery. Flagship tier vendor pack.
              
          
        

      
      
          Tags
          
            remofirstsaassdkintegration
          
        
    
  

  

    

    
    
        
            
                Stay in the Loop
                
                    
                    
                    
                
                No spam. Unsubscribe anytime.
            

            
                
                    Product
                    
                        Explore
                        Skills
                        Cowork
                        Compare
                        Tools
                    
                
                
                    Resources
                    
                        Changelog
                        Collections
                        Playbooks
                        Research
                        Learning
                    
                
                
                    Company
                    
                        Community
                        Spotlight
                        GitHub
                    
                
                
                    Legal
                    
                        Privacy
                        Terms
                        Acceptable Use
                    
                
            

            
                Tons of Skills by Intent Solutions. Marine. Citadel Grad. 20 years ops → self-taught dev → AI architect.
                © 2026 Tons of Skills | Intent Solutions

Aspect	Workflow A	Workflow B
Use Case	Primary	Secondary
Complexity	Medium	Lower
Performance	Standard	Optimized

Error	Cause	Solution
Invalid API Key	Incorrect or expired key	Verify key in RemoFirst dashboard
Rate Limited	Exceeded quota	Check quota at https://docs.remofirst.com
Network Error	Firewall blocking	Ensure outbound HTTPS allowed
Module Not Found	Installation failed	Run `npm install` or `pip install` again

Alert	Condition	Severity
API Down	5xx errors > 10/min	P1
High Latency	p99 > 5000ms	P2
Rate Limited	429 errors > 5/min	P2
Auth Failures	401/403 errors > 0	P1

remofirst-pack

Installation

Skills (12)

RemoFirst Common Errors

Overview

Prerequisites

Instructions

Step 1: Identify the Error

Step 2: Find Matching Error Below

Step 3: Apply Solution

Output

Error Handling

Authentication Failed

Rate Limit Exceeded

Network Timeout

Examples

Quick Diagnostic Commands

Escalation Path

Resources

Next Steps

RemoFirst Core Workflow A

Overview

Prerequisites

Instructions

Step 1: Initialize

Step 2: Execute

Step 3: Finalize

Output

Error Handling

Examples

Complete Workflow

Common Variations

Resources

Next Steps

RemoFirst Core Workflow B

Overview

Prerequisites

Instructions

Step 1: Setup

Step 2: Process

Step 3: Complete

Output

Error Handling

Examples

Complete Workflow

Error Recovery

Resources

Next Steps

RemoFirst Debug Bundle

Overview

Prerequisites

Instructions

Step 1: Create Debug Bundle Script

Step 2: Collect Environment Info

Step 3: Gather SDK and Logs

Step 4: Package Bundle

Output

Error Handling

RemoFirst Hello World

Overview

Prerequisites

Instructions

Step 1: Create Entry File

Step 2: Import and Initialize Client

Step 3: Make Your First API Call

Output

Error Handling

Examples

TypeScript Example

Python Example

Resources

Next Steps

RemoFirst Install & Auth

Overview

Prerequisites

Instructions

Step 1: Install SDK

Step 2: Configure Authentication

Step 3: Verify Connection

Output