@renseiai/agentfactory-server 0.8.0

package/dist/src/redis-circuit-breaker.js

@@ -0,0 +1,290 @@
+/**
+ * Redis Circuit Breaker
+ *
+ * Shares circuit breaker state across processes via Redis.
+ * All processes (dashboard, governor, CLI agents) see the same
+ * circuit state for a workspace.
+ *
+ * Redis keys:
+ * - `linear:circuit:{workspaceId}:state`    — 'closed' | 'open' | 'half-open'
+ * - `linear:circuit:{workspaceId}:failures` — consecutive failure count (with TTL)
+ * - `linear:circuit:{workspaceId}:opened_at` — timestamp when circuit was opened
+ * - `linear:circuit:{workspaceId}:reset_timeout` — current reset timeout (for backoff)
+ *
+ * Implements CircuitBreakerStrategy from @renseiai/agentfactory-linear
+ * so it can be injected into LinearAgentClient.
+ */
+import { getRedisClient } from './redis.js';
+import { createLogger } from './logger.js';
+const log = createLogger('redis-circuit-breaker');
+const DEFAULT_CONFIG = {
+    failureThreshold: 2,
+    resetTimeoutMs: 60_000,
+    maxResetTimeoutMs: 300_000,
+    backoffMultiplier: 2,
+    authErrorCodes: [400, 401, 403],
+};
+/**
+ * Lua script for atomic circuit breaker state check.
+ *
+ * KEYS[1] = state key
+ * KEYS[2] = opened_at key
+ * KEYS[3] = reset_timeout key
+ * ARGV[1] = current timestamp (ms)
+ * ARGV[2] = default reset timeout (ms)
+ *
+ * Returns: 1 if call can proceed, 0 if blocked, 2 if probe (half-open)
+ */
+const CAN_PROCEED_LUA = `
+local stateKey = KEYS[1]
+local openedAtKey = KEYS[2]
+local resetTimeoutKey = KEYS[3]
+local now = tonumber(ARGV[1])
+local defaultResetTimeout = tonumber(ARGV[2])
+
+local state = redis.call('GET', stateKey)
+
+-- Closed or no state: allow
+if state == false or state == 'closed' then
+  return 1
+end
+
+-- Open: check if reset timeout has elapsed
+if state == 'open' then
+  local openedAt = tonumber(redis.call('GET', openedAtKey)) or 0
+  local resetTimeout = tonumber(redis.call('GET', resetTimeoutKey)) or defaultResetTimeout
+
+  if (now - openedAt) >= resetTimeout then
+    -- Transition to half-open: allow one probe
+    redis.call('SET', stateKey, 'half-open', 'EX', 3600)
+    return 2
+  end
+
+  return 0
+end
+
+-- Half-open: block (probe already in flight)
+-- The first caller to see 'open' -> 'half-open' transition gets the probe
+if state == 'half-open' then
+  return 0
+end
+
+return 1
+`;
+/**
+ * Lua script for recording auth failure.
+ *
+ * KEYS[1] = state key
+ * KEYS[2] = failures key
+ * KEYS[3] = opened_at key
+ * KEYS[4] = reset_timeout key
+ * ARGV[1] = failure threshold
+ * ARGV[2] = current timestamp (ms)
+ * ARGV[3] = default reset timeout (ms)
+ * ARGV[4] = backoff multiplier
+ * ARGV[5] = max reset timeout (ms)
+ *
+ * Returns: new state ('closed', 'open')
+ */
+const RECORD_FAILURE_LUA = `
+local stateKey = KEYS[1]
+local failuresKey = KEYS[2]
+local openedAtKey = KEYS[3]
+local resetTimeoutKey = KEYS[4]
+local threshold = tonumber(ARGV[1])
+local now = tonumber(ARGV[2])
+local defaultResetTimeout = tonumber(ARGV[3])
+local backoffMultiplier = tonumber(ARGV[4])
+local maxResetTimeout = tonumber(ARGV[5])
+
+local state = redis.call('GET', stateKey) or 'closed'
+local failures = tonumber(redis.call('INCR', failuresKey))
+redis.call('EXPIRE', failuresKey, 3600)
+
+-- If half-open: probe failed, reopen with backoff
+if state == 'half-open' then
+  local currentTimeout = tonumber(redis.call('GET', resetTimeoutKey)) or defaultResetTimeout
+  local newTimeout = math.min(currentTimeout * backoffMultiplier, maxResetTimeout)
+  redis.call('SET', stateKey, 'open', 'EX', 3600)
+  redis.call('SET', openedAtKey, tostring(now), 'EX', 3600)
+  redis.call('SET', resetTimeoutKey, tostring(newTimeout), 'EX', 3600)
+  return 'open'
+end
+
+-- If closed and at threshold: trip to open
+if failures >= threshold then
+  redis.call('SET', stateKey, 'open', 'EX', 3600)
+  redis.call('SET', openedAtKey, tostring(now), 'EX', 3600)
+  redis.call('SET', resetTimeoutKey, tostring(defaultResetTimeout), 'EX', 3600)
+  return 'open'
+end
+
+return 'closed'
+`;
+export class RedisCircuitBreaker {
+    config;
+    keyPrefix;
+    constructor(config) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.keyPrefix = `linear:circuit:${this.config.workspaceId}`;
+    }
+    get stateKey() {
+        return `${this.keyPrefix}:state`;
+    }
+    get failuresKey() {
+        return `${this.keyPrefix}:failures`;
+    }
+    get openedAtKey() {
+        return `${this.keyPrefix}:opened_at`;
+    }
+    get resetTimeoutKey() {
+        return `${this.keyPrefix}:reset_timeout`;
+    }
+    /**
+     * Check if a call is allowed to proceed.
+     */
+    async canProceed() {
+        try {
+            const redis = getRedisClient();
+            const result = await redis.eval(CAN_PROCEED_LUA, 3, this.stateKey, this.openedAtKey, this.resetTimeoutKey, String(Date.now()), String(this.config.resetTimeoutMs));
+            // 1 = closed (allow), 2 = half-open probe (allow), 0 = blocked
+            return result === 1 || result === 2;
+        }
+        catch (err) {
+            // If Redis is down, allow the request (fail open for circuit breaker)
+            log.error('Redis circuit breaker error, failing open', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+            return true;
+        }
+    }
+    /**
+     * Record a successful API call. Resets the circuit to closed.
+     */
+    async recordSuccess() {
+        try {
+            const redis = getRedisClient();
+            const pipeline = redis.pipeline();
+            pipeline.set(this.stateKey, 'closed', 'EX', 3600);
+            pipeline.del(this.failuresKey);
+            pipeline.del(this.openedAtKey);
+            pipeline.del(this.resetTimeoutKey);
+            await pipeline.exec();
+        }
+        catch (err) {
+            log.error('Failed to record circuit breaker success', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    /**
+     * Record an auth failure. May trip the circuit to open.
+     */
+    async recordAuthFailure(_statusCode) {
+        try {
+            const redis = getRedisClient();
+            const result = await redis.eval(RECORD_FAILURE_LUA, 4, this.stateKey, this.failuresKey, this.openedAtKey, this.resetTimeoutKey, String(this.config.failureThreshold), String(Date.now()), String(this.config.resetTimeoutMs), String(this.config.backoffMultiplier), String(this.config.maxResetTimeoutMs));
+            if (result === 'open') {
+                log.warn('Circuit breaker tripped to OPEN', {
+                    workspaceId: this.config.workspaceId,
+                });
+            }
+        }
+        catch (err) {
+            log.error('Failed to record circuit breaker failure', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    /**
+     * Check if an error is an auth/rate-limit error.
+     * Reuses the same detection logic as the in-memory CircuitBreaker.
+     */
+    isAuthError(error) {
+        if (typeof error !== 'object' || error === null)
+            return false;
+        const err = error;
+        // Check HTTP status code
+        const statusCode = (typeof err.status === 'number' ? err.status : undefined) ??
+            (typeof err.statusCode === 'number' ? err.statusCode : undefined) ??
+            (typeof err.response?.status === 'number'
+                ? err.response.status
+                : undefined);
+        if (statusCode !== undefined && this.config.authErrorCodes.includes(statusCode)) {
+            return true;
+        }
+        // Check for GraphQL RATELIMITED
+        const extensions = err.extensions;
+        if (extensions?.code === 'RATELIMITED')
+            return true;
+        const errors = err.errors;
+        if (Array.isArray(errors)) {
+            for (const gqlError of errors) {
+                const ext = gqlError.extensions;
+                if (ext?.code === 'RATELIMITED')
+                    return true;
+            }
+        }
+        // Check error message patterns
+        const message = err.message ?? '';
+        if (/access denied|unauthorized|forbidden|RATELIMITED/i.test(message)) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Reset the circuit breaker to closed state.
+     */
+    async reset() {
+        try {
+            const redis = getRedisClient();
+            const pipeline = redis.pipeline();
+            pipeline.set(this.stateKey, 'closed', 'EX', 3600);
+            pipeline.del(this.failuresKey);
+            pipeline.del(this.openedAtKey);
+            pipeline.del(this.resetTimeoutKey);
+            await pipeline.exec();
+        }
+        catch (err) {
+            log.error('Failed to reset circuit breaker', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    /**
+     * Get diagnostic info for monitoring.
+     */
+    async getStatus() {
+        try {
+            const redis = getRedisClient();
+            const [state, failures, openedAt, resetTimeout] = await Promise.all([
+                redis.get(this.stateKey),
+                redis.get(this.failuresKey),
+                redis.get(this.openedAtKey),
+                redis.get(this.resetTimeoutKey),
+            ]);
+            return {
+                state: state ?? 'closed',
+                failures: failures ? parseInt(failures, 10) : 0,
+                openedAt: openedAt ? parseInt(openedAt, 10) : null,
+                currentResetTimeoutMs: resetTimeout
+                    ? parseInt(resetTimeout, 10)
+                    : this.config.resetTimeoutMs,
+            };
+        }
+        catch {
+            return {
+                state: 'unknown',
+                failures: -1,
+                openedAt: null,
+                currentResetTimeoutMs: this.config.resetTimeoutMs,
+            };
+        }
+    }
+}
+/**
+ * Create a Redis circuit breaker for a specific workspace.
+ */
+export function createRedisCircuitBreaker(workspaceId, config) {
+    return new RedisCircuitBreaker({ ...config, workspaceId });
+}

package/dist/src/redis-rate-limiter.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Redis Token Bucket Rate Limiter
+ *
+ * Atomic token bucket implementation using Redis + Lua script.
+ * All processes (dashboard, governor, CLI agents) share one bucket
+ * keyed by `linear:rate-limit:{workspaceId}`.
+ *
+ * Implements RateLimiterStrategy from @renseiai/agentfactory-linear
+ * so it can be injected into LinearAgentClient.
+ */
+import type { RateLimiterStrategy } from '@renseiai/agentfactory-linear';
+export interface RedisTokenBucketConfig {
+    /** Redis key for this bucket (default: 'linear:rate-limit:default') */
+    key: string;
+    /** Maximum tokens (burst capacity). Default: 80 */
+    maxTokens: number;
+    /** Tokens added per second. Default: 1.5 (~90/min) */
+    refillRate: number;
+    /** Maximum time to wait for a token before throwing (ms). Default: 30_000 */
+    acquireTimeoutMs: number;
+    /** Polling interval when waiting for tokens (ms). Default: 500 */
+    pollIntervalMs: number;
+}
+export declare const DEFAULT_REDIS_RATE_LIMIT_CONFIG: RedisTokenBucketConfig;
+export declare class RedisTokenBucket implements RateLimiterStrategy {
+    private readonly config;
+    constructor(config?: Partial<RedisTokenBucketConfig>);
+    /**
+     * Acquire a single token. Polls Redis until a token is available
+     * or the acquire timeout is reached.
+     */
+    acquire(): Promise<void>;
+    /**
+     * Penalize the bucket after receiving a rate limit response.
+     * Drains all tokens and sets a penalty period.
+     */
+    penalize(seconds: number): Promise<void>;
+    /**
+     * Try to acquire a token atomically. Returns true if acquired.
+     */
+    private tryAcquire;
+    /**
+     * Get the current token count (for monitoring).
+     */
+    getAvailableTokens(): Promise<number>;
+}
+/**
+ * Create a Redis token bucket for a specific workspace.
+ */
+export declare function createRedisTokenBucket(workspaceId: string, config?: Partial<Omit<RedisTokenBucketConfig, 'key'>>): RedisTokenBucket;
+//# sourceMappingURL=redis-rate-limiter.d.ts.map

package/dist/src/redis-rate-limiter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-rate-limiter.d.ts","sourceRoot":"","sources":["../../src/redis-rate-limiter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAA;AAIxE,MAAM,WAAW,sBAAsB;IACrC,uEAAuE;IACvE,GAAG,EAAE,MAAM,CAAA;IACX,mDAAmD;IACnD,SAAS,EAAE,MAAM,CAAA;IACjB,sDAAsD;IACtD,UAAU,EAAE,MAAM,CAAA;IAClB,6EAA6E;IAC7E,gBAAgB,EAAE,MAAM,CAAA;IACxB,kEAAkE;IAClE,cAAc,EAAE,MAAM,CAAA;CACvB;AAED,eAAO,MAAM,+BAA+B,EAAE,sBAM7C,CAAA;AAyED,qBAAa,gBAAiB,YAAW,mBAAmB;IAC1D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAwB;gBAEnC,MAAM,CAAC,EAAE,OAAO,CAAC,sBAAsB,CAAC;IAIpD;;;OAGG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAqB9B;;;OAGG;IACG,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAkB9C;;OAEG;YACW,UAAU;IAqBxB;;OAEG;IACG,kBAAkB,IAAI,OAAO,CAAC,MAAM,CAAC;CAS5C;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,MAAM,EACnB,MAAM,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,sBAAsB,EAAE,KAAK,CAAC,CAAC,GACpD,gBAAgB,CAKlB"}

package/dist/src/redis-rate-limiter.js

@@ -0,0 +1,168 @@
+/**
+ * Redis Token Bucket Rate Limiter
+ *
+ * Atomic token bucket implementation using Redis + Lua script.
+ * All processes (dashboard, governor, CLI agents) share one bucket
+ * keyed by `linear:rate-limit:{workspaceId}`.
+ *
+ * Implements RateLimiterStrategy from @renseiai/agentfactory-linear
+ * so it can be injected into LinearAgentClient.
+ */
+import { getRedisClient } from './redis.js';
+import { createLogger } from './logger.js';
+const log = createLogger('redis-rate-limiter');
+export const DEFAULT_REDIS_RATE_LIMIT_CONFIG = {
+    key: 'linear:rate-limit:default',
+    maxTokens: 80,
+    refillRate: 1.5,
+    acquireTimeoutMs: 30_000,
+    pollIntervalMs: 500,
+};
+/**
+ * Lua script for atomic token bucket acquire.
+ *
+ * KEYS[1] = bucket key (hash with fields: tokens, last_refill, penalty_until)
+ * ARGV[1] = maxTokens
+ * ARGV[2] = refillRate (tokens per second)
+ * ARGV[3] = current timestamp (ms)
+ *
+ * Returns: 1 if token acquired, 0 if no tokens available
+ */
+const ACQUIRE_LUA = `
+local key = KEYS[1]
+local maxTokens = tonumber(ARGV[1])
+local refillRate = tonumber(ARGV[2])
+local now = tonumber(ARGV[3])
+
+-- Initialize bucket if it doesn't exist
+local tokens = tonumber(redis.call('HGET', key, 'tokens'))
+local lastRefill = tonumber(redis.call('HGET', key, 'last_refill'))
+local penaltyUntil = tonumber(redis.call('HGET', key, 'penalty_until')) or 0
+
+if tokens == nil then
+  tokens = maxTokens
+  lastRefill = now
+  redis.call('HMSET', key, 'tokens', tokens, 'last_refill', lastRefill, 'penalty_until', 0)
+  redis.call('EXPIRE', key, 3600)
+end
+
+-- Check if we're in a penalty period
+if now < penaltyUntil then
+  return 0
+end
+
+-- Refill tokens based on elapsed time
+local elapsed = (now - lastRefill) / 1000.0
+if elapsed > 0 then
+  local newTokens = elapsed * refillRate
+  tokens = math.min(maxTokens, tokens + newTokens)
+  lastRefill = now
+end
+
+-- Try to acquire a token
+if tokens >= 1 then
+  tokens = tokens - 1
+  redis.call('HMSET', key, 'tokens', tokens, 'last_refill', lastRefill)
+  redis.call('EXPIRE', key, 3600)
+  return 1
+end
+
+redis.call('HMSET', key, 'tokens', tokens, 'last_refill', lastRefill)
+redis.call('EXPIRE', key, 3600)
+return 0
+`;
+/**
+ * Lua script for penalizing the bucket (after rate limit response).
+ *
+ * KEYS[1] = bucket key
+ * ARGV[1] = penalty duration (seconds)
+ * ARGV[2] = current timestamp (ms)
+ */
+const PENALIZE_LUA = `
+local key = KEYS[1]
+local penaltySeconds = tonumber(ARGV[1])
+local now = tonumber(ARGV[2])
+
+redis.call('HMSET', key, 'tokens', 0, 'penalty_until', now + (penaltySeconds * 1000))
+redis.call('EXPIRE', key, 3600)
+return 1
+`;
+export class RedisTokenBucket {
+    config;
+    constructor(config) {
+        this.config = { ...DEFAULT_REDIS_RATE_LIMIT_CONFIG, ...config };
+    }
+    /**
+     * Acquire a single token. Polls Redis until a token is available
+     * or the acquire timeout is reached.
+     */
+    async acquire() {
+        const start = Date.now();
+        while (true) {
+            const acquired = await this.tryAcquire();
+            if (acquired)
+                return;
+            // Check timeout
+            if (Date.now() - start > this.config.acquireTimeoutMs) {
+                throw new Error(`RedisTokenBucket: timed out waiting for rate limit token after ${this.config.acquireTimeoutMs}ms`);
+            }
+            // Wait before polling again
+            await new Promise((resolve) => setTimeout(resolve, this.config.pollIntervalMs));
+        }
+    }
+    /**
+     * Penalize the bucket after receiving a rate limit response.
+     * Drains all tokens and sets a penalty period.
+     */
+    async penalize(seconds) {
+        try {
+            const redis = getRedisClient();
+            await redis.eval(PENALIZE_LUA, 1, this.config.key, String(seconds), String(Date.now()));
+            log.warn('Rate limit penalty applied', { seconds, key: this.config.key });
+        }
+        catch (err) {
+            log.error('Failed to apply rate limit penalty', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    /**
+     * Try to acquire a token atomically. Returns true if acquired.
+     */
+    async tryAcquire() {
+        try {
+            const redis = getRedisClient();
+            const result = await redis.eval(ACQUIRE_LUA, 1, this.config.key, String(this.config.maxTokens), String(this.config.refillRate), String(Date.now()));
+            return result === 1;
+        }
+        catch (err) {
+            // If Redis is down, allow the request (fail open for rate limiting)
+            log.error('Redis rate limiter error, failing open', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+            return true;
+        }
+    }
+    /**
+     * Get the current token count (for monitoring).
+     */
+    async getAvailableTokens() {
+        try {
+            const redis = getRedisClient();
+            const tokens = await redis.hget(this.config.key, 'tokens');
+            return tokens ? parseFloat(tokens) : this.config.maxTokens;
+        }
+        catch {
+            return -1;
+        }
+    }
+}
+/**
+ * Create a Redis token bucket for a specific workspace.
+ */
+export function createRedisTokenBucket(workspaceId, config) {
+    return new RedisTokenBucket({
+        ...config,
+        key: `linear:rate-limit:${workspaceId}`,
+    });
+}

package/dist/src/redis.d.ts

@@ -0,0 +1,146 @@
+import Redis from 'ioredis';
+/**
+ * Check if Redis is configured via REDIS_URL
+ */
+export declare function isRedisConfigured(): boolean;
+/**
+ * Get the shared Redis client instance
+ * Lazily initialized to avoid errors during build
+ */
+export declare function getRedisClient(): Redis;
+/**
+ * Disconnect Redis client (for graceful shutdown)
+ */
+export declare function disconnectRedis(): Promise<void>;
+/**
+ * Set a value with optional TTL (seconds)
+ */
+export declare function redisSet<T>(key: string, value: T, ttlSeconds?: number): Promise<void>;
+/**
+ * Get a typed value
+ */
+export declare function redisGet<T>(key: string): Promise<T | null>;
+/**
+ * Delete a key
+ * @returns number of keys deleted (0 or 1)
+ */
+export declare function redisDel(key: string): Promise<number>;
+/**
+ * Check if a key exists
+ */
+export declare function redisExists(key: string): Promise<boolean>;
+/**
+ * Get keys matching a pattern
+ */
+export declare function redisKeys(pattern: string): Promise<string[]>;
+/**
+ * Push value to the right of a list (RPUSH)
+ * @returns length of list after push
+ */
+export declare function redisRPush(key: string, value: string): Promise<number>;
+/**
+ * Pop value from the left of a list (LPOP)
+ * @returns the popped value or null if list is empty
+ */
+export declare function redisLPop(key: string): Promise<string | null>;
+/**
+ * Get a range of elements from a list (LRANGE)
+ * @param start - Start index (0-based, inclusive)
+ * @param stop - Stop index (inclusive, -1 for end)
+ */
+export declare function redisLRange(key: string, start: number, stop: number): Promise<string[]>;
+/**
+ * Get the length of a list (LLEN)
+ */
+export declare function redisLLen(key: string): Promise<number>;
+/**
+ * Remove elements from a list (LREM)
+ * @param count - Number of occurrences to remove (0 = all)
+ * @returns number of elements removed
+ */
+export declare function redisLRem(key: string, count: number, value: string): Promise<number>;
+/**
+ * Add member to a set (SADD)
+ * @returns number of elements added (0 if already exists)
+ */
+export declare function redisSAdd(key: string, member: string): Promise<number>;
+/**
+ * Remove member from a set (SREM)
+ * @returns number of elements removed
+ */
+export declare function redisSRem(key: string, member: string): Promise<number>;
+/**
+ * Get all members of a set (SMEMBERS)
+ */
+export declare function redisSMembers(key: string): Promise<string[]>;
+/**
+ * Get the number of members in a set (SCARD)
+ */
+export declare function redisSCard(key: string): Promise<number>;
+/**
+ * Set a value only if key does not exist (SETNX)
+ * @returns true if key was set, false if it already existed
+ */
+export declare function redisSetNX(key: string, value: string, ttlSeconds?: number): Promise<boolean>;
+/**
+ * Set TTL on an existing key (EXPIRE)
+ * @returns true if TTL was set, false if key doesn't exist
+ */
+export declare function redisExpire(key: string, ttlSeconds: number): Promise<boolean>;
+/**
+ * Add member to a sorted set with score (ZADD)
+ * @returns number of elements added (0 if already exists, updates score)
+ */
+export declare function redisZAdd(key: string, score: number, member: string): Promise<number>;
+/**
+ * Remove member from a sorted set (ZREM)
+ * @returns number of elements removed
+ */
+export declare function redisZRem(key: string, member: string): Promise<number>;
+/**
+ * Get members from sorted set by score range (ZRANGEBYSCORE)
+ * Returns members with lowest scores first (highest priority)
+ * @param min - Minimum score (use '-inf' for no minimum)
+ * @param max - Maximum score (use '+inf' for no maximum)
+ * @param limit - Maximum number of results
+ */
+export declare function redisZRangeByScore(key: string, min: number | string, max: number | string, limit?: number): Promise<string[]>;
+/**
+ * Get the number of members in a sorted set (ZCARD)
+ */
+export declare function redisZCard(key: string): Promise<number>;
+/**
+ * Pop the member with the lowest score (ZPOPMIN)
+ * @returns [member, score] or null if set is empty
+ */
+export declare function redisZPopMin(key: string): Promise<{
+    member: string;
+    score: number;
+} | null>;
+/**
+ * Set a field in a hash (HSET)
+ * @returns 1 if field is new, 0 if field existed
+ */
+export declare function redisHSet(key: string, field: string, value: string): Promise<number>;
+/**
+ * Get a field from a hash (HGET)
+ */
+export declare function redisHGet(key: string, field: string): Promise<string | null>;
+/**
+ * Delete a field from a hash (HDEL)
+ * @returns number of fields removed
+ */
+export declare function redisHDel(key: string, field: string): Promise<number>;
+/**
+ * Get multiple fields from a hash (HMGET)
+ */
+export declare function redisHMGet(key: string, fields: string[]): Promise<(string | null)[]>;
+/**
+ * Get all fields and values from a hash (HGETALL)
+ */
+export declare function redisHGetAll(key: string): Promise<Record<string, string>>;
+/**
+ * Get the number of fields in a hash (HLEN)
+ */
+export declare function redisHLen(key: string): Promise<number>;
+//# sourceMappingURL=redis.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"redis.d.ts","sourceRoot":"","sources":["../../src/redis.ts"],"names":[],"mappings":"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"}