@supaku/agentfactory-server 0.1.0

package/dist/src/session-storage.js

@@ -0,0 +1,349 @@
+import { isRedisConfigured, redisSet, redisGet, redisDel, redisKeys } from './redis';
+const log = {
+    info: (msg, data) => console.log(`[session] ${msg}`, data ? JSON.stringify(data) : ''),
+    warn: (msg, data) => console.warn(`[session] ${msg}`, data ? JSON.stringify(data) : ''),
+    error: (msg, data) => console.error(`[session] ${msg}`, data ? JSON.stringify(data) : ''),
+    debug: (_msg, _data) => { },
+};
+/**
+ * Key prefix for session state in KV
+ */
+const SESSION_KEY_PREFIX = 'agent:session:';
+/**
+ * Session state TTL in seconds (24 hours)
+ * Sessions older than this are automatically cleaned up by KV
+ */
+const SESSION_TTL_SECONDS = 24 * 60 * 60;
+/**
+ * Build the KV key for a session
+ */
+function buildSessionKey(linearSessionId) {
+    return `${SESSION_KEY_PREFIX}${linearSessionId}`;
+}
+/**
+ * Store agent session state in Redis
+ *
+ * @param linearSessionId - The Linear session ID from webhook
+ * @param state - The session state to store
+ */
+export async function storeSessionState(linearSessionId, state) {
+    if (!isRedisConfigured()) {
+        log.warn('Redis not configured, session state will not be persisted');
+        const now = Math.floor(Date.now() / 1000);
+        return {
+            ...state,
+            linearSessionId,
+            createdAt: now,
+            updatedAt: now,
+        };
+    }
+    const now = Math.floor(Date.now() / 1000);
+    const key = buildSessionKey(linearSessionId);
+    // Check for existing session to preserve createdAt
+    const existing = await redisGet(key);
+    const sessionState = {
+        ...state,
+        linearSessionId,
+        createdAt: existing?.createdAt ?? now,
+        updatedAt: now,
+    };
+    await redisSet(key, sessionState, SESSION_TTL_SECONDS);
+    log.info('Stored session state', {
+        linearSessionId,
+        issueId: state.issueId,
+        status: state.status,
+        hasClaudeSessionId: !!state.claudeSessionId,
+    });
+    return sessionState;
+}
+/**
+ * Retrieve agent session state from Redis
+ *
+ * @param linearSessionId - The Linear session ID
+ * @returns The session state or null if not found
+ */
+export async function getSessionState(linearSessionId) {
+    if (!isRedisConfigured()) {
+        log.debug('Redis not configured, cannot retrieve session state');
+        return null;
+    }
+    const key = buildSessionKey(linearSessionId);
+    const state = await redisGet(key);
+    if (state) {
+        log.debug('Retrieved session state', {
+            linearSessionId,
+            issueId: state.issueId,
+            status: state.status,
+        });
+    }
+    return state;
+}
+/**
+ * Update the Claude session ID for a session
+ * Called when the Claude init event is received with the session ID
+ *
+ * @param linearSessionId - The Linear session ID
+ * @param claudeSessionId - The Claude CLI session ID
+ */
+export async function updateClaudeSessionId(linearSessionId, claudeSessionId) {
+    if (!isRedisConfigured()) {
+        log.warn('Redis not configured, cannot update Claude session ID');
+        return false;
+    }
+    const existing = await getSessionState(linearSessionId);
+    if (!existing) {
+        log.warn('Session not found for Claude session ID update', { linearSessionId });
+        return false;
+    }
+    const key = buildSessionKey(linearSessionId);
+    const now = Math.floor(Date.now() / 1000);
+    const updated = {
+        ...existing,
+        claudeSessionId,
+        updatedAt: now,
+    };
+    await redisSet(key, updated, SESSION_TTL_SECONDS);
+    log.info('Updated Claude session ID', { linearSessionId, claudeSessionId });
+    return true;
+}
+/**
+ * Update session status
+ *
+ * @param linearSessionId - The Linear session ID
+ * @param status - The new status
+ */
+export async function updateSessionStatus(linearSessionId, status) {
+    if (!isRedisConfigured()) {
+        log.warn('Redis not configured, cannot update session status');
+        return false;
+    }
+    const existing = await getSessionState(linearSessionId);
+    if (!existing) {
+        log.warn('Session not found for status update', { linearSessionId });
+        return false;
+    }
+    const key = buildSessionKey(linearSessionId);
+    const now = Math.floor(Date.now() / 1000);
+    const updated = {
+        ...existing,
+        status,
+        updatedAt: now,
+    };
+    await redisSet(key, updated, SESSION_TTL_SECONDS);
+    log.info('Updated session status', { linearSessionId, status });
+    return true;
+}
+/**
+ * Reset a session for re-queuing after orphan cleanup
+ * Clears workerId and resets status to pending so a new worker can claim it
+ *
+ * @param linearSessionId - The Linear session ID
+ */
+export async function resetSessionForRequeue(linearSessionId) {
+    if (!isRedisConfigured()) {
+        log.warn('Redis not configured, cannot reset session');
+        return false;
+    }
+    const existing = await getSessionState(linearSessionId);
+    if (!existing) {
+        log.warn('Session not found for reset', { linearSessionId });
+        return false;
+    }
+    const key = buildSessionKey(linearSessionId);
+    const now = Math.floor(Date.now() / 1000);
+    const updated = {
+        ...existing,
+        status: 'pending',
+        workerId: undefined, // Clear workerId so new worker can claim
+        claimedAt: undefined,
+        updatedAt: now,
+    };
+    await redisSet(key, updated, SESSION_TTL_SECONDS);
+    log.info('Reset session for requeue', {
+        linearSessionId,
+        previousWorkerId: existing.workerId,
+    });
+    return true;
+}
+/**
+ * Delete session state from KV
+ *
+ * @param linearSessionId - The Linear session ID
+ * @returns Whether the deletion was successful
+ */
+export async function deleteSessionState(linearSessionId) {
+    if (!isRedisConfigured()) {
+        return false;
+    }
+    const key = buildSessionKey(linearSessionId);
+    const result = await redisDel(key);
+    log.info('Deleted session state', { linearSessionId });
+    return result > 0;
+}
+/**
+ * Get session state by issue ID
+ * Useful when we have the issue but not the session ID
+ *
+ * @param issueId - The Linear issue ID
+ * @returns The most recent session state for this issue or null
+ */
+export async function getSessionStateByIssue(issueId) {
+    if (!isRedisConfigured()) {
+        return null;
+    }
+    // Scan for sessions with this issue ID
+    // Note: This is less efficient than direct lookup, use sparingly
+    const keys = await redisKeys(`${SESSION_KEY_PREFIX}*`);
+    for (const key of keys) {
+        const state = await redisGet(key);
+        if (state?.issueId === issueId) {
+            return state;
+        }
+    }
+    return null;
+}
+// ============================================
+// Worker Pool Operations
+// ============================================
+/**
+ * Mark a session as claimed by a worker
+ *
+ * @param linearSessionId - The Linear session ID
+ * @param workerId - The worker claiming the session
+ */
+export async function claimSession(linearSessionId, workerId) {
+    if (!isRedisConfigured()) {
+        return false;
+    }
+    const existing = await getSessionState(linearSessionId);
+    if (!existing) {
+        log.warn('Session not found for claim', { linearSessionId });
+        return false;
+    }
+    if (existing.status !== 'pending') {
+        log.warn('Session not in pending status', {
+            linearSessionId,
+            status: existing.status,
+        });
+        return false;
+    }
+    const key = buildSessionKey(linearSessionId);
+    const now = Math.floor(Date.now() / 1000);
+    const updated = {
+        ...existing,
+        status: 'claimed',
+        workerId,
+        claimedAt: now,
+        updatedAt: now,
+    };
+    await redisSet(key, updated, SESSION_TTL_SECONDS);
+    log.info('Session claimed', { linearSessionId, workerId });
+    return true;
+}
+/**
+ * Update session with worker info when work starts
+ *
+ * @param linearSessionId - The Linear session ID
+ * @param workerId - The worker processing the session
+ * @param worktreePath - Path to the git worktree
+ */
+export async function startSession(linearSessionId, workerId, worktreePath) {
+    if (!isRedisConfigured()) {
+        return false;
+    }
+    const existing = await getSessionState(linearSessionId);
+    if (!existing) {
+        log.warn('Session not found for start', { linearSessionId });
+        return false;
+    }
+    const key = buildSessionKey(linearSessionId);
+    const now = Math.floor(Date.now() / 1000);
+    const updated = {
+        ...existing,
+        status: 'running',
+        workerId,
+        worktreePath,
+        updatedAt: now,
+    };
+    await redisSet(key, updated, SESSION_TTL_SECONDS);
+    log.info('Session started', { linearSessionId, workerId, worktreePath });
+    return true;
+}
+/**
+ * Get all sessions from Redis
+ * For dashboard display
+ */
+export async function getAllSessions() {
+    if (!isRedisConfigured()) {
+        return [];
+    }
+    try {
+        const keys = await redisKeys(`${SESSION_KEY_PREFIX}*`);
+        const sessions = [];
+        for (const key of keys) {
+            const state = await redisGet(key);
+            if (state) {
+                sessions.push(state);
+            }
+        }
+        // Sort by updatedAt descending (most recent first)
+        sessions.sort((a, b) => b.updatedAt - a.updatedAt);
+        return sessions;
+    }
+    catch (error) {
+        log.error('Failed to get all sessions', { error });
+        return [];
+    }
+}
+/**
+ * Get sessions by status
+ */
+export async function getSessionsByStatus(status) {
+    const allSessions = await getAllSessions();
+    const statusArray = Array.isArray(status) ? status : [status];
+    return allSessions.filter((s) => statusArray.includes(s.status));
+}
+/**
+ * Transfer session ownership to a new worker
+ * Used when a worker re-registers after disconnection and gets a new ID
+ *
+ * @param linearSessionId - The Linear session ID
+ * @param newWorkerId - The new worker ID to assign
+ * @param oldWorkerId - The previous worker ID (for validation)
+ * @returns Whether the transfer was successful
+ */
+export async function transferSessionOwnership(linearSessionId, newWorkerId, oldWorkerId) {
+    if (!isRedisConfigured()) {
+        return { transferred: false, reason: 'Redis not configured' };
+    }
+    const existing = await getSessionState(linearSessionId);
+    if (!existing) {
+        return { transferred: false, reason: 'Session not found' };
+    }
+    // Validate that the old worker ID matches (security check)
+    if (existing.workerId && existing.workerId !== oldWorkerId) {
+        log.warn('Session ownership transfer rejected - worker ID mismatch', {
+            linearSessionId,
+            expectedWorkerId: oldWorkerId,
+            actualWorkerId: existing.workerId,
+        });
+        return {
+            transferred: false,
+            reason: `Session owned by different worker: ${existing.workerId}`,
+        };
+    }
+    const key = buildSessionKey(linearSessionId);
+    const now = Math.floor(Date.now() / 1000);
+    const updated = {
+        ...existing,
+        workerId: newWorkerId,
+        updatedAt: now,
+    };
+    await redisSet(key, updated, SESSION_TTL_SECONDS);
+    log.info('Session ownership transferred', {
+        linearSessionId,
+        oldWorkerId,
+        newWorkerId,
+    });
+    return { transferred: true };
+}

package/dist/src/types.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Shared types for the server package
+ *
+ * AgentWorkType is re-exported from here until @supaku/agentfactory-linear
+ * provides it. Consumers should import from this module.
+ */
+/**
+ * Type of agent work being performed based on issue status
+ */
+export type AgentWorkType = 'research' | 'backlog-creation' | 'development' | 'inflight' | 'qa' | 'acceptance' | 'refinement' | 'coordination' | 'qa-coordination' | 'acceptance-coordination';
+//# sourceMappingURL=types.d.ts.map

package/dist/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,MAAM,MAAM,aAAa,GACrB,UAAU,GACV,kBAAkB,GAClB,aAAa,GACb,UAAU,GACV,IAAI,GACJ,YAAY,GACZ,YAAY,GACZ,cAAc,GACd,iBAAiB,GACjB,yBAAyB,CAAA"}

package/dist/src/types.js

@@ -0,0 +1,7 @@
+/**
+ * Shared types for the server package
+ *
+ * AgentWorkType is re-exported from here until @supaku/agentfactory-linear
+ * provides it. Consumers should import from this module.
+ */
+export {};

package/dist/src/webhook-idempotency.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Webhook Idempotency Module
+ *
+ * Prevents duplicate webhook processing using a two-layer approach:
+ * 1. In-memory Set for fast local checks (avoids network latency)
+ * 2. Redis for distributed/persistent storage (survives restarts)
+ *
+ * Uses webhookId (unique per delivery) as the primary key, falling back
+ * to sessionId if webhookId is not available.
+ */
+/**
+ * Generate an idempotency key from webhook data
+ * Prefers webhookId (unique per delivery), falls back to sessionId
+ */
+export declare function generateIdempotencyKey(webhookId: string | undefined, sessionId: string): string;
+/**
+ * Check if a webhook has already been processed
+ * First checks in-memory cache, then falls back to KV
+ *
+ * @param idempotencyKey - The key generated from generateIdempotencyKey
+ * @returns Whether the webhook was already processed
+ */
+export declare function isWebhookProcessed(idempotencyKey: string): Promise<boolean>;
+/**
+ * Mark a webhook as processed in both memory and KV
+ *
+ * @param idempotencyKey - The key generated from generateIdempotencyKey
+ */
+export declare function markWebhookProcessed(idempotencyKey: string): Promise<void>;
+/**
+ * Remove a webhook from processed state (for cleanup after failed spawn)
+ *
+ * @param idempotencyKey - The key generated from generateIdempotencyKey
+ */
+export declare function unmarkWebhookProcessed(idempotencyKey: string): Promise<void>;
+/**
+ * Get current cache statistics (for monitoring)
+ */
+export declare function getCacheStats(): {
+    memorySize: number;
+    memoryExpiryMs: number;
+    kvExpirySeconds: number;
+};
+//# sourceMappingURL=webhook-idempotency.d.ts.map

package/dist/src/webhook-idempotency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook-idempotency.d.ts","sourceRoot":"","sources":["../../src/webhook-idempotency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAyCH;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,SAAS,EAAE,MAAM,GAChB,MAAM,CAOR;AAED;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CACtC,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,OAAO,CAAC,CA4BlB;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,IAAI,CAAC,CAgBf;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,CAC1C,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,IAAI,CAAC,CAcf;AAWD;;GAEG;AACH,wBAAgB,aAAa,IAAI;IAC/B,UAAU,EAAE,MAAM,CAAA;IAClB,cAAc,EAAE,MAAM,CAAA;IACtB,eAAe,EAAE,MAAM,CAAA;CACxB,CAMA"}

package/dist/src/webhook-idempotency.js

@@ -0,0 +1,148 @@
+/**
+ * Webhook Idempotency Module
+ *
+ * Prevents duplicate webhook processing using a two-layer approach:
+ * 1. In-memory Set for fast local checks (avoids network latency)
+ * 2. Redis for distributed/persistent storage (survives restarts)
+ *
+ * Uses webhookId (unique per delivery) as the primary key, falling back
+ * to sessionId if webhookId is not available.
+ */
+import { isRedisConfigured, redisSet, redisExists, redisDel } from './redis';
+const log = {
+    info: (msg, data) => console.log(`[idempotency] ${msg}`, data ? JSON.stringify(data) : ''),
+    warn: (msg, data) => console.warn(`[idempotency] ${msg}`, data ? JSON.stringify(data) : ''),
+    error: (msg, data) => console.error(`[idempotency] ${msg}`, data ? JSON.stringify(data) : ''),
+    debug: (_msg, _data) => { },
+};
+/**
+ * Key prefix for webhook idempotency keys in KV
+ */
+const WEBHOOK_KEY_PREFIX = 'webhook:processed:';
+/**
+ * Time window for deduplication (24 hours)
+ * Linear's retry window is typically 24-48 hours
+ */
+const DEDUP_WINDOW_SECONDS = 24 * 60 * 60;
+/**
+ * In-memory expiry for local cache (5 minutes)
+ * Shorter than KV to prevent memory growth
+ */
+const MEMORY_EXPIRY_MS = 5 * 60 * 1000;
+/**
+ * In-memory cache for fast local checks
+ * Maps idempotency key to timestamp when it was added
+ */
+const processedWebhooks = new Map();
+/**
+ * Build the KV key for a webhook idempotency entry
+ */
+function buildWebhookKey(idempotencyKey) {
+    return `${WEBHOOK_KEY_PREFIX}${idempotencyKey}`;
+}
+/**
+ * Generate an idempotency key from webhook data
+ * Prefers webhookId (unique per delivery), falls back to sessionId
+ */
+export function generateIdempotencyKey(webhookId, sessionId) {
+    // webhookId is unique per delivery attempt - best for idempotency
+    if (webhookId) {
+        return `wh:${webhookId}`;
+    }
+    // Fallback to sessionId if webhookId not available
+    return `session:${sessionId}`;
+}
+/**
+ * Check if a webhook has already been processed
+ * First checks in-memory cache, then falls back to KV
+ *
+ * @param idempotencyKey - The key generated from generateIdempotencyKey
+ * @returns Whether the webhook was already processed
+ */
+export async function isWebhookProcessed(idempotencyKey) {
+    // Fast path: check in-memory cache first
+    if (processedWebhooks.has(idempotencyKey)) {
+        log.info(`Cache hit (memory): ${idempotencyKey}`);
+        return true;
+    }
+    // Slow path: check Redis for distributed/persistent state
+    if (isRedisConfigured()) {
+        try {
+            const key = buildWebhookKey(idempotencyKey);
+            const exists = await redisExists(key);
+            if (exists) {
+                log.info(`Cache hit (Redis): ${idempotencyKey}`);
+                // Warm up memory cache for subsequent checks
+                processedWebhooks.set(idempotencyKey, Date.now());
+                scheduleMemoryCleanup(idempotencyKey);
+                return true;
+            }
+        }
+        catch (err) {
+            // Log but don't fail - better to potentially double-process
+            // than to block legitimate webhooks
+            log.error('KV check failed', { error: err });
+        }
+    }
+    return false;
+}
+/**
+ * Mark a webhook as processed in both memory and KV
+ *
+ * @param idempotencyKey - The key generated from generateIdempotencyKey
+ */
+export async function markWebhookProcessed(idempotencyKey) {
+    // Always update memory cache
+    processedWebhooks.set(idempotencyKey, Date.now());
+    scheduleMemoryCleanup(idempotencyKey);
+    // Persist to Redis for distributed state
+    if (isRedisConfigured()) {
+        try {
+            const key = buildWebhookKey(idempotencyKey);
+            await redisSet(key, Date.now(), DEDUP_WINDOW_SECONDS);
+            log.info(`Marked processed in Redis: ${idempotencyKey}`);
+        }
+        catch (err) {
+            // Log but don't fail - memory cache provides some protection
+            log.error('Redis write failed', { error: err });
+        }
+    }
+}
+/**
+ * Remove a webhook from processed state (for cleanup after failed spawn)
+ *
+ * @param idempotencyKey - The key generated from generateIdempotencyKey
+ */
+export async function unmarkWebhookProcessed(idempotencyKey) {
+    // Remove from memory
+    processedWebhooks.delete(idempotencyKey);
+    // Remove from Redis
+    if (isRedisConfigured()) {
+        try {
+            const key = buildWebhookKey(idempotencyKey);
+            await redisDel(key);
+            log.info(`Removed from Redis: ${idempotencyKey}`);
+        }
+        catch (err) {
+            log.error('Redis delete failed', { error: err });
+        }
+    }
+}
+/**
+ * Schedule cleanup of memory cache entry after expiry
+ */
+function scheduleMemoryCleanup(idempotencyKey) {
+    setTimeout(() => {
+        processedWebhooks.delete(idempotencyKey);
+    }, MEMORY_EXPIRY_MS);
+}
+/**
+ * Get current cache statistics (for monitoring)
+ */
+export function getCacheStats() {
+    return {
+        memorySize: processedWebhooks.size,
+        memoryExpiryMs: MEMORY_EXPIRY_MS,
+        kvExpirySeconds: DEDUP_WINDOW_SECONDS,
+    };
+}

package/dist/src/work-queue.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Work Queue Module (Optimized)
+ *
+ * Manages the queue of pending agent work items in Redis.
+ * Workers poll this queue to claim and process work.
+ *
+ * Data Structures (optimized for high concurrency):
+ * - work:items (Hash): sessionId -> JSON work item - O(1) lookup
+ * - work:queue (Sorted Set): score = priority, member = sessionId - O(log n) operations
+ * - work:claim:{sessionId} (String): workerId with TTL - atomic claims
+ *
+ * Performance:
+ * - queueWork: O(log n) - HSET + ZADD
+ * - claimWork: O(log n) - SETNX + HGET + ZREM
+ * - peekWork: O(log n + k) - ZRANGEBYSCORE + HMGET where k = limit
+ * - getQueueLength: O(1) - ZCARD
+ */
+import type { AgentWorkType } from './types';
+/**
+ * Type of work being performed
+ * @deprecated Use AgentWorkType from './types' instead
+ */
+export type WorkType = AgentWorkType;
+/**
+ * Work item stored in the queue
+ */
+export interface QueuedWork {
+    sessionId: string;
+    issueId: string;
+    issueIdentifier: string;
+    priority: number;
+    queuedAt: number;
+    prompt?: string;
+    claudeSessionId?: string;
+    workType?: AgentWorkType;
+    sourceSessionId?: string;
+}
+/**
+ * Add work to the queue
+ *
+ * @param work - Work item to queue
+ * @returns true if queued successfully
+ */
+export declare function queueWork(work: QueuedWork): Promise<boolean>;
+/**
+ * Peek at pending work without removing from queue
+ * Returns items sorted by priority (lowest number = highest priority)
+ *
+ * @param limit - Maximum number of items to return
+ * @returns Array of work items sorted by priority
+ */
+export declare function peekWork(limit?: number): Promise<QueuedWork[]>;
+/**
+ * Get the number of items in the queue
+ */
+export declare function getQueueLength(): Promise<number>;
+/**
+ * Claim a work item for processing
+ *
+ * Uses SETNX for atomic claim to prevent race conditions.
+ * O(log n) complexity for claim + remove operations.
+ *
+ * @param sessionId - Session ID to claim
+ * @param workerId - Worker claiming the work
+ * @returns The work item if claimed successfully, null otherwise
+ */
+export declare function claimWork(sessionId: string, workerId: string): Promise<QueuedWork | null>;
+/**
+ * Release a work claim (e.g., on failure or cancellation)
+ *
+ * @param sessionId - Session ID to release
+ * @returns true if released successfully
+ */
+export declare function releaseClaim(sessionId: string): Promise<boolean>;
+/**
+ * Check which worker has claimed a session
+ *
+ * @param sessionId - Session ID to check
+ * @returns Worker ID if claimed, null otherwise
+ */
+export declare function getClaimOwner(sessionId: string): Promise<string | null>;
+/**
+ * Check if a session has an entry in the work queue.
+ * O(1) check via the work items hash.
+ *
+ * @param sessionId - Session ID to check
+ * @returns true if the session is present in the work queue
+ */
+export declare function isSessionInQueue(sessionId: string): Promise<boolean>;
+/**
+ * Re-queue work that failed or was abandoned
+ *
+ * @param work - Work item to re-queue
+ * @param priorityBoost - Decrease priority number (higher priority) by this amount
+ * @returns true if re-queued successfully
+ */
+export declare function requeueWork(work: QueuedWork, priorityBoost?: number): Promise<boolean>;
+/**
+ * Get all pending work items (for dashboard/monitoring)
+ * Returns items sorted by priority
+ */
+export declare function getAllPendingWork(): Promise<QueuedWork[]>;
+/**
+ * Remove a work item from queue (without claiming)
+ * Used for cleanup operations
+ *
+ * @param sessionId - Session ID to remove
+ * @returns true if removed
+ */
+export declare function removeFromQueue(sessionId: string): Promise<boolean>;
+/**
+ * Migrate data from legacy list-based queue to new sorted set/hash structure
+ * Run this once after deployment to migrate existing data
+ */
+export declare function migrateFromLegacyQueue(): Promise<{
+    migrated: number;
+    failed: number;
+}>;
+//# sourceMappingURL=work-queue.d.ts.map

package/dist/src/work-queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"work-queue.d.ts","sourceRoot":"","sources":["../../src/work-queue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAqBH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAoB5C;;;GAGG;AACH,MAAM,MAAM,QAAQ,GAAG,aAAa,CAAA;AAEpC;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,eAAe,EAAE,MAAM,CAAA;IACvB,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,EAAE,aAAa,CAAA;IACxB,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB;AAeD;;;;;GAKG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,CA4BlE;AAED;;;;;;GAMG;AACH,wBAAsB,QAAQ,CAAC,KAAK,GAAE,MAAW,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAuCxE;AAED;;GAEG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC,CAWtD;AAED;;;;;;;;;GASG;AACH,wBAAsB,SAAS,CAC7B,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CA6C5B;AAED;;;;;GAKG;AACH,wBAAsB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAatE;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAY7E;AAED;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAY1E;AAED;;;;;;GAMG;AACH,wBAAsB,WAAW,CAC/B,IAAI,EAAE,UAAU,EAChB,aAAa,GAAE,MAAU,GACxB,OAAO,CAAC,OAAO,CAAC,CAwBlB;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC,CAgC/D;AAED;;;;;;GAMG;AACH,wBAAsB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAczE;AAED;;;GAGG;AACH,wBAAsB,sBAAsB,IAAI,OAAO,CAAC;IACtD,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;CACf,CAAC,CA8CD"}