@supaku/agentfactory-server 0.1.2 → 0.2.0

package/dist/src/orphan-cleanup.js

@@ -0,0 +1,335 @@
+/**
+ * Orphan Cleanup Module
+ *
+ * Detects and handles orphaned sessions - sessions marked as running/claimed
+ * but whose worker is no longer active (heartbeat timeout).
+ *
+ * When a worker disconnects, the work is re-queued for another worker to resume.
+ * The Linear issue status is NOT rolled back - the issue remains in its current
+ * workflow state and the next worker will resume from where the previous one left off.
+ */
+import { createLogger } from './logger';
+import { getAllSessions, resetSessionForRequeue, } from './session-storage';
+import { listWorkers } from './worker-storage';
+import { releaseClaim, isSessionInQueue, } from './work-queue';
+import { dispatchWork, cleanupExpiredLocksWithPendingWork, cleanupStaleLocksWithIdleWorkers, isSessionParkedForIssue, } from './issue-lock';
+const log = createLogger('orphan-cleanup');
+// How long a session can be running without a valid worker before being considered orphaned
+const ORPHAN_THRESHOLD_MS = 120_000; // 2 minutes (worker TTL + buffer)
+/**
+ * Find sessions that are orphaned (running/claimed but worker is gone)
+ */
+export async function findOrphanedSessions() {
+    const [sessions, workers] = await Promise.all([
+        getAllSessions(),
+        listWorkers(),
+    ]);
+    // Build set of active worker IDs
+    const activeWorkerIds = new Set(workers
+        .filter((w) => w.status === 'active')
+        .map((w) => w.id));
+    const orphaned = [];
+    for (const session of sessions) {
+        // Only check running or claimed sessions
+        if (session.status !== 'running' && session.status !== 'claimed') {
+            continue;
+        }
+        // If session has no worker assigned, it's orphaned
+        if (!session.workerId) {
+            log.debug('Session has no worker assigned', {
+                sessionId: session.linearSessionId,
+                status: session.status,
+            });
+            orphaned.push(session);
+            continue;
+        }
+        // If the assigned worker is no longer active, session is orphaned
+        if (!activeWorkerIds.has(session.workerId)) {
+            log.debug('Session worker is no longer active', {
+                sessionId: session.linearSessionId,
+                workerId: session.workerId,
+                status: session.status,
+            });
+            orphaned.push(session);
+            continue;
+        }
+    }
+    return orphaned;
+}
+// How long a pending session can exist without a queue entry before being considered a zombie
+const ZOMBIE_PENDING_THRESHOLD_MS = 5 * 60 * 1000; // 5 minutes
+/**
+ * Find zombie pending sessions — sessions stuck in `pending` status
+ * that have no corresponding entry in the work queue or any issue-pending queue.
+ *
+ * These arise when:
+ * - claimWork() removes from queue, but claimSession() fails and requeue also fails
+ * - Issue lock expires but promotion fails silently
+ */
+export async function findZombiePendingSessions() {
+    const sessions = await getAllSessions();
+    const now = Date.now();
+    const zombies = [];
+    for (const session of sessions) {
+        if (session.status !== 'pending')
+            continue;
+        // Only consider sessions older than the threshold
+        const age = now - session.updatedAt;
+        if (age < ZOMBIE_PENDING_THRESHOLD_MS)
+            continue;
+        // Check if session is in the global work queue
+        const inQueue = await isSessionInQueue(session.linearSessionId);
+        if (inQueue)
+            continue;
+        // Check if session is parked in the issue-pending queue
+        const parked = await isSessionParkedForIssue(session.issueId, session.linearSessionId);
+        if (parked)
+            continue;
+        // Session is pending but not in any queue — it's a zombie
+        log.warn('Found zombie pending session', {
+            sessionId: session.linearSessionId,
+            issueIdentifier: session.issueIdentifier,
+            ageMinutes: Math.round(age / 60_000),
+        });
+        zombies.push(session);
+    }
+    return zombies;
+}
+/**
+ * Clean up orphaned sessions by re-queuing them
+ *
+ * @param callbacks - Optional callbacks for external integrations (e.g., posting Linear comments)
+ */
+export async function cleanupOrphanedSessions(callbacks) {
+    const result = {
+        checked: 0,
+        orphaned: 0,
+        requeued: 0,
+        failed: 0,
+        details: [],
+        worktreePathsToCleanup: [],
+    };
+    try {
+        const sessions = await getAllSessions();
+        result.checked = sessions.length;
+        const orphaned = await findOrphanedSessions();
+        result.orphaned = orphaned.length;
+        if (orphaned.length > 0) {
+            log.info('Found orphaned sessions', { count: orphaned.length });
+        }
+        for (const session of orphaned) {
+            try {
+                const issueIdentifier = session.issueIdentifier || session.issueId.slice(0, 8);
+                log.info('Re-queuing orphaned session', {
+                    sessionId: session.linearSessionId,
+                    issueIdentifier,
+                    previousWorker: session.workerId,
+                    previousStatus: session.status,
+                });
+                // Release any existing claim
+                await releaseClaim(session.linearSessionId);
+                // Reset session for requeue (clears workerId so new worker can claim)
+                await resetSessionForRequeue(session.linearSessionId);
+                // Re-queue the work with higher priority
+                // IMPORTANT: Preserve workType to prevent incorrect status transitions
+                // NOTE: Do NOT preserve claudeSessionId - the old session may be corrupted
+                // from the crash that caused the orphan. Starting fresh is safer.
+                const work = {
+                    sessionId: session.linearSessionId,
+                    issueId: session.issueId,
+                    issueIdentifier,
+                    priority: Math.max(1, (session.priority || 3) - 1), // Boost priority
+                    queuedAt: Date.now(),
+                    prompt: session.promptContext,
+                    // claudeSessionId intentionally omitted - don't resume crashed sessions
+                    workType: session.workType,
+                };
+                const dispatchResult = await dispatchWork(work);
+                if (dispatchResult.dispatched || dispatchResult.parked) {
+                    result.requeued++;
+                    result.details.push({
+                        sessionId: session.linearSessionId,
+                        issueIdentifier,
+                        action: 'requeued',
+                        worktreePath: session.worktreePath,
+                    });
+                    // Track worktree path for cleanup on worker machines
+                    if (session.worktreePath) {
+                        result.worktreePathsToCleanup.push(session.worktreePath);
+                    }
+                    // Call external callback (e.g., post Linear comment)
+                    if (callbacks?.onOrphanRequeued) {
+                        try {
+                            await callbacks.onOrphanRequeued(session);
+                        }
+                        catch (err) {
+                            log.warn('onOrphanRequeued callback failed', { error: err });
+                        }
+                    }
+                }
+                else {
+                    result.failed++;
+                    result.details.push({
+                        sessionId: session.linearSessionId,
+                        issueIdentifier,
+                        action: 'failed',
+                        reason: 'Failed to queue work',
+                    });
+                }
+            }
+            catch (err) {
+                log.error('Failed to cleanup orphaned session', {
+                    sessionId: session.linearSessionId,
+                    error: err,
+                });
+                result.failed++;
+                result.details.push({
+                    sessionId: session.linearSessionId,
+                    issueIdentifier: session.issueIdentifier || 'unknown',
+                    action: 'failed',
+                    reason: err instanceof Error ? err.message : 'Unknown error',
+                });
+            }
+        }
+        // Check for zombie pending sessions (pending but not in any queue)
+        try {
+            const zombies = await findZombiePendingSessions();
+            if (zombies.length > 0) {
+                log.info('Found zombie pending sessions', { count: zombies.length });
+            }
+            for (const session of zombies) {
+                try {
+                    const issueIdentifier = session.issueIdentifier || session.issueId.slice(0, 8);
+                    log.info('Re-dispatching zombie pending session', {
+                        sessionId: session.linearSessionId,
+                        issueIdentifier,
+                    });
+                    const work = {
+                        sessionId: session.linearSessionId,
+                        issueId: session.issueId,
+                        issueIdentifier,
+                        priority: Math.max(1, (session.priority || 3) - 1),
+                        queuedAt: Date.now(),
+                        prompt: session.promptContext,
+                        workType: session.workType,
+                    };
+                    const dispatchResult = await dispatchWork(work);
+                    if (dispatchResult.dispatched || dispatchResult.parked) {
+                        result.requeued++;
+                        result.details.push({
+                            sessionId: session.linearSessionId,
+                            issueIdentifier,
+                            action: 'requeued',
+                            reason: 'Zombie pending session recovered',
+                        });
+                        // Call external callback
+                        if (callbacks?.onZombieRecovered) {
+                            try {
+                                await callbacks.onZombieRecovered(session);
+                            }
+                            catch (err) {
+                                log.warn('onZombieRecovered callback failed', { error: err });
+                            }
+                        }
+                    }
+                    else {
+                        result.failed++;
+                        result.details.push({
+                            sessionId: session.linearSessionId,
+                            issueIdentifier,
+                            action: 'failed',
+                            reason: 'Failed to re-dispatch zombie session',
+                        });
+                    }
+                }
+                catch (err) {
+                    log.error('Failed to recover zombie session', {
+                        sessionId: session.linearSessionId,
+                        error: err,
+                    });
+                    result.failed++;
+                    result.details.push({
+                        sessionId: session.linearSessionId,
+                        issueIdentifier: session.issueIdentifier || 'unknown',
+                        action: 'failed',
+                        reason: err instanceof Error ? err.message : 'Unknown error',
+                    });
+                }
+            }
+        }
+        catch (err) {
+            log.error('Failed to find zombie pending sessions', { error: err });
+        }
+        // Also check for expired issue locks with pending work
+        try {
+            const promoted = await cleanupExpiredLocksWithPendingWork();
+            if (promoted > 0) {
+                log.info('Promoted pending work from expired issue locks', { promoted });
+            }
+        }
+        catch (err) {
+            log.error('Failed to cleanup expired issue locks', { error: err });
+        }
+        // Check for stale locks held by completed sessions when workers have idle capacity.
+        // Only runs when workers are online — no point promoting if nobody can pick it up.
+        try {
+            const workers = await listWorkers();
+            const activeWorkers = workers.filter((w) => w.status === 'active');
+            const hasIdleWorkers = activeWorkers.length > 0 &&
+                activeWorkers.some((w) => w.activeCount < w.capacity);
+            if (hasIdleWorkers) {
+                const promoted = await cleanupStaleLocksWithIdleWorkers(hasIdleWorkers);
+                if (promoted > 0) {
+                    log.info('Promoted parked work from stale issue locks', { promoted });
+                }
+            }
+        }
+        catch (err) {
+            log.error('Failed to cleanup stale issue locks', { error: err });
+        }
+        log.info('Orphan cleanup completed', {
+            checked: result.checked,
+            orphaned: result.orphaned,
+            requeued: result.requeued,
+            failed: result.failed,
+            worktreePathsToCleanup: result.worktreePathsToCleanup.length,
+        });
+        // Log worktree cleanup info if any paths need attention
+        if (result.worktreePathsToCleanup.length > 0) {
+            log.info('Worktree cleanup needed on worker machines', {
+                paths: result.worktreePathsToCleanup,
+                note: 'Run cleanup-worktrees on each worker machine to remove orphaned worktrees',
+            });
+        }
+    }
+    catch (err) {
+        log.error('Orphan cleanup failed', { error: err });
+    }
+    return result;
+}
+/**
+ * Check if cleanup should run based on time since last cleanup
+ * Returns true if enough time has passed
+ */
+let lastCleanupTime = 0;
+const CLEANUP_INTERVAL_MS = 60_000; // Run at most once per minute
+export function shouldRunCleanup() {
+    const now = Date.now();
+    if (now - lastCleanupTime >= CLEANUP_INTERVAL_MS) {
+        lastCleanupTime = now;
+        return true;
+    }
+    return false;
+}
+/**
+ * Run cleanup if enough time has passed (debounced)
+ * Safe to call frequently - will only actually run periodically
+ *
+ * @param callbacks - Optional callbacks for external integrations
+ */
+export async function maybeCleanupOrphans(callbacks) {
+    if (!shouldRunCleanup()) {
+        return null;
+    }
+    return cleanupOrphanedSessions(callbacks);
+}

package/dist/src/pending-prompts.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Pending Prompts Module
+ *
+ * Stores follow-up prompts for running agent sessions.
+ * Workers poll for pending prompts and forward them to their running Claude processes.
+ */
+/**
+ * A pending prompt waiting to be delivered to a running agent
+ */
+export interface PendingPrompt {
+    id: string;
+    sessionId: string;
+    issueId: string;
+    prompt: string;
+    userId?: string;
+    userName?: string;
+    createdAt: number;
+}
+/**
+ * Store a pending prompt for a session
+ *
+ * @param sessionId - The Linear session ID
+ * @param issueId - The Linear issue ID
+ * @param prompt - The prompt text from the user
+ * @param user - Optional user info
+ * @returns The created prompt or null if storage failed
+ */
+export declare function storePendingPrompt(sessionId: string, issueId: string, prompt: string, user?: {
+    id?: string;
+    name?: string;
+}): Promise<PendingPrompt | null>;
+/**
+ * Get all pending prompts for a session
+ *
+ * @param sessionId - The Linear session ID
+ * @returns Array of pending prompts (oldest first)
+ */
+export declare function getPendingPrompts(sessionId: string): Promise<PendingPrompt[]>;
+/**
+ * Get the count of pending prompts for a session
+ */
+export declare function getPendingPromptCount(sessionId: string): Promise<number>;
+/**
+ * Claim and remove a pending prompt by ID
+ * Returns the prompt if found and removed, null otherwise
+ *
+ * @param sessionId - The Linear session ID
+ * @param promptId - The prompt ID to claim
+ * @returns The claimed prompt or null
+ */
+export declare function claimPendingPrompt(sessionId: string, promptId: string): Promise<PendingPrompt | null>;
+/**
+ * Pop the oldest pending prompt for a session (claim and remove atomically)
+ *
+ * @param sessionId - The Linear session ID
+ * @returns The oldest pending prompt or null if none
+ */
+export declare function popPendingPrompt(sessionId: string): Promise<PendingPrompt | null>;
+/**
+ * Clear all pending prompts for a session
+ * Called when session completes or is stopped
+ *
+ * @param sessionId - The Linear session ID
+ * @returns true if cleared successfully
+ */
+export declare function clearPendingPrompts(sessionId: string): Promise<boolean>;
+//# sourceMappingURL=pending-prompts.d.ts.map

package/dist/src/pending-prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pending-prompts.d.ts","sourceRoot":"","sources":["../../src/pending-prompts.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAiBH;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAA;IACV,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;CAClB;AAgBD;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CACtC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE;IAAE,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GACpC,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CAiC/B;AAED;;;;;GAKG;AACH,wBAAsB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CAanF;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAY9E;AAED;;;;;;;GAOG;AACH,wBAAsB,kBAAkB,CACtC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CAwB/B;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CAkBvF;AAED;;;;;;GAMG;AACH,wBAAsB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAc7E"}

package/dist/src/pending-prompts.js

@@ -0,0 +1,176 @@
+/**
+ * Pending Prompts Module
+ *
+ * Stores follow-up prompts for running agent sessions.
+ * Workers poll for pending prompts and forward them to their running Claude processes.
+ */
+import { redisRPush, redisLRange, redisLRem, redisLLen, redisDel, isRedisConfigured, } from './redis';
+import { createLogger } from './logger';
+const log = createLogger('pending-prompts');
+// Redis key prefix for pending prompts per session
+const PENDING_PROMPTS_PREFIX = 'session:prompts:';
+/**
+ * Build the Redis key for a session's pending prompts
+ */
+function buildPromptsKey(sessionId) {
+    return `${PENDING_PROMPTS_PREFIX}${sessionId}`;
+}
+/**
+ * Generate a unique prompt ID
+ */
+function generatePromptId() {
+    return `prm_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
+}
+/**
+ * Store a pending prompt for a session
+ *
+ * @param sessionId - The Linear session ID
+ * @param issueId - The Linear issue ID
+ * @param prompt - The prompt text from the user
+ * @param user - Optional user info
+ * @returns The created prompt or null if storage failed
+ */
+export async function storePendingPrompt(sessionId, issueId, prompt, user) {
+    if (!isRedisConfigured()) {
+        log.warn('Redis not configured, cannot store pending prompt');
+        return null;
+    }
+    try {
+        const pendingPrompt = {
+            id: generatePromptId(),
+            sessionId,
+            issueId,
+            prompt,
+            userId: user?.id,
+            userName: user?.name,
+            createdAt: Date.now(),
+        };
+        const key = buildPromptsKey(sessionId);
+        const serialized = JSON.stringify(pendingPrompt);
+        await redisRPush(key, serialized);
+        log.info('Pending prompt stored', {
+            promptId: pendingPrompt.id,
+            sessionId,
+            issueId,
+            promptLength: prompt.length,
+        });
+        return pendingPrompt;
+    }
+    catch (error) {
+        log.error('Failed to store pending prompt', { error, sessionId, issueId });
+        return null;
+    }
+}
+/**
+ * Get all pending prompts for a session
+ *
+ * @param sessionId - The Linear session ID
+ * @returns Array of pending prompts (oldest first)
+ */
+export async function getPendingPrompts(sessionId) {
+    if (!isRedisConfigured()) {
+        return [];
+    }
+    try {
+        const key = buildPromptsKey(sessionId);
+        const items = await redisLRange(key, 0, -1);
+        return items.map((item) => JSON.parse(item));
+    }
+    catch (error) {
+        log.error('Failed to get pending prompts', { error, sessionId });
+        return [];
+    }
+}
+/**
+ * Get the count of pending prompts for a session
+ */
+export async function getPendingPromptCount(sessionId) {
+    if (!isRedisConfigured()) {
+        return 0;
+    }
+    try {
+        const key = buildPromptsKey(sessionId);
+        return await redisLLen(key);
+    }
+    catch (error) {
+        log.error('Failed to get pending prompt count', { error, sessionId });
+        return 0;
+    }
+}
+/**
+ * Claim and remove a pending prompt by ID
+ * Returns the prompt if found and removed, null otherwise
+ *
+ * @param sessionId - The Linear session ID
+ * @param promptId - The prompt ID to claim
+ * @returns The claimed prompt or null
+ */
+export async function claimPendingPrompt(sessionId, promptId) {
+    if (!isRedisConfigured()) {
+        return null;
+    }
+    try {
+        const key = buildPromptsKey(sessionId);
+        const items = await redisLRange(key, 0, -1);
+        for (const item of items) {
+            const prompt = JSON.parse(item);
+            if (prompt.id === promptId) {
+                // Remove this specific item from the list
+                await redisLRem(key, 1, item);
+                log.info('Pending prompt claimed', { promptId, sessionId });
+                return prompt;
+            }
+        }
+        return null;
+    }
+    catch (error) {
+        log.error('Failed to claim pending prompt', { error, sessionId, promptId });
+        return null;
+    }
+}
+/**
+ * Pop the oldest pending prompt for a session (claim and remove atomically)
+ *
+ * @param sessionId - The Linear session ID
+ * @returns The oldest pending prompt or null if none
+ */
+export async function popPendingPrompt(sessionId) {
+    if (!isRedisConfigured()) {
+        return null;
+    }
+    try {
+        const prompts = await getPendingPrompts(sessionId);
+        if (prompts.length === 0) {
+            return null;
+        }
+        const oldest = prompts[0];
+        const claimed = await claimPendingPrompt(sessionId, oldest.id);
+        return claimed;
+    }
+    catch (error) {
+        log.error('Failed to pop pending prompt', { error, sessionId });
+        return null;
+    }
+}
+/**
+ * Clear all pending prompts for a session
+ * Called when session completes or is stopped
+ *
+ * @param sessionId - The Linear session ID
+ * @returns true if cleared successfully
+ */
+export async function clearPendingPrompts(sessionId) {
+    if (!isRedisConfigured()) {
+        return false;
+    }
+    try {
+        const key = buildPromptsKey(sessionId);
+        await redisDel(key);
+        log.info('Pending prompts cleared', { sessionId });
+        return true;
+    }
+    catch (error) {
+        log.error('Failed to clear pending prompts', { error, sessionId });
+        return false;
+    }
+}

package/dist/src/rate-limit.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Rate Limiter with LRU Cache
+ *
+ * In-memory rate limiting using sliding window algorithm.
+ * Uses LRU cache to prevent memory bloat from tracking many IPs.
+ */
+/**
+ * Rate limit configuration
+ */
+export interface RateLimitConfig {
+    /** Maximum requests allowed in the window */
+    limit: number;
+    /** Window size in milliseconds */
+    windowMs: number;
+}
+/**
+ * Rate limit check result
+ */
+export interface RateLimitResult {
+    /** Whether the request is allowed */
+    allowed: boolean;
+    /** Remaining requests in current window */
+    remaining: number;
+    /** Time until window resets (milliseconds) */
+    resetIn: number;
+    /** Total limit for this endpoint */
+    limit: number;
+}
+/**
+ * Default rate limit configurations by endpoint type
+ */
+export declare const RATE_LIMITS: {
+    /** Public API endpoints - 60 requests per minute */
+    readonly public: {
+        readonly limit: 60;
+        readonly windowMs: number;
+    };
+    /** Webhook endpoint - 10 requests per second per IP */
+    readonly webhook: {
+        readonly limit: 10;
+        readonly windowMs: 1000;
+    };
+    /** Dashboard - 30 requests per minute */
+    readonly dashboard: {
+        readonly limit: 30;
+        readonly windowMs: number;
+    };
+};
+/**
+ * LRU Rate Limiter
+ *
+ * Tracks request counts per key (typically IP address) using
+ * sliding window algorithm. Old entries are evicted using LRU policy.
+ */
+export declare class RateLimiter {
+    private cache;
+    private maxEntries;
+    private config;
+    constructor(config: RateLimitConfig, maxEntries?: number);
+    /**
+     * Check if a request should be allowed
+     *
+     * @param key - Unique identifier (usually IP address)
+     * @returns Rate limit result
+     */
+    check(key: string): RateLimitResult;
+    /**
+     * Evict least recently used entries if cache is full
+     */
+    private evictIfNeeded;
+    /**
+     * Clear all entries (useful for testing)
+     */
+    clear(): void;
+    /**
+     * Get current cache size
+     */
+    get size(): number;
+}
+/**
+ * Get or create a rate limiter for an endpoint type
+ *
+ * @param type - Endpoint type ('public', 'webhook', 'dashboard')
+ * @returns Rate limiter instance
+ */
+export declare function getRateLimiter(type: keyof typeof RATE_LIMITS): RateLimiter;
+/**
+ * Check rate limit for a request
+ *
+ * @param type - Endpoint type
+ * @param key - Unique identifier (usually IP)
+ * @returns Rate limit result
+ */
+export declare function checkRateLimit(type: keyof typeof RATE_LIMITS, key: string): RateLimitResult;
+/**
+ * Extract client IP from request headers
+ *
+ * Handles various proxy scenarios (Vercel, Cloudflare, etc.)
+ *
+ * @param headers - Request headers
+ * @returns Client IP address
+ */
+export declare function getClientIP(headers: Headers): string;
+/**
+ * Build rate limit headers for response
+ *
+ * @param result - Rate limit result
+ * @returns Headers object
+ */
+export declare function buildRateLimitHeaders(result: RateLimitResult): Record<string, string>;
+//# sourceMappingURL=rate-limit.d.ts.map

package/dist/src/rate-limit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limit.d.ts","sourceRoot":"","sources":["../../src/rate-limit.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,6CAA6C;IAC7C,KAAK,EAAE,MAAM,CAAA;IACb,kCAAkC;IAClC,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,qCAAqC;IACrC,OAAO,EAAE,OAAO,CAAA;IAChB,2CAA2C;IAC3C,SAAS,EAAE,MAAM,CAAA;IACjB,8CAA8C;IAC9C,OAAO,EAAE,MAAM,CAAA;IACf,oCAAoC;IACpC,KAAK,EAAE,MAAM,CAAA;CACd;AAYD;;GAEG;AACH,eAAO,MAAM,WAAW;IACtB,oDAAoD;;;;;IAEpD,uDAAuD;;;;;IAEvD,yCAAyC;;;;;CAEjC,CAAA;AAEV;;;;;GAKG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,KAAK,CAAyC;IACtD,OAAO,CAAC,UAAU,CAAQ;IAC1B,OAAO,CAAC,MAAM,CAAiB;gBAEnB,MAAM,EAAE,eAAe,EAAE,UAAU,SAAQ;IAKvD;;;;;OAKG;IACH,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe;IA4CnC;;OAEG;IACH,OAAO,CAAC,aAAa;IAgBrB;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF;AAKD;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,OAAO,WAAW,GAC7B,WAAW,CAOb;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,OAAO,WAAW,EAC9B,GAAG,EAAE,MAAM,GACV,eAAe,CAGjB;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAsBpD;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,eAAe,GACtB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAMxB"}