@pikku/redis 0.12.19 → 0.12.21

package/src/redis-agent-run-service.ts

@@ -1,207 +0,0 @@
-import type {
-  AgentThread,
-  AgentMessage,
-  AgentRunRow,
-  AgentRunService,
-} from '@pikku/core/agent'
-import { isOwnedByPrincipal } from '@pikku/core/agent'
-import type { Redis } from 'ioredis'
-
-export class RedisAgentRunService implements AgentRunService {
-  constructor(
-    private redis: Redis,
-    private keyPrefix = 'ai'
-  ) {}
-
-  private threadKey(threadId: string): string {
-    return `${this.keyPrefix}:thread:${threadId}`
-  }
-
-  private threadsIndexKey(): string {
-    return `${this.keyPrefix}:threads`
-  }
-
-  private messagesKey(threadId: string): string {
-    return `${this.keyPrefix}:messages:${threadId}`
-  }
-
-  private runKey(runId: string): string {
-    return `${this.keyPrefix}:run:${runId}`
-  }
-
-  private threadRunsKey(threadId: string): string {
-    return `${this.keyPrefix}:thread-runs:${threadId}`
-  }
-
-  private agentThreadsKey(agentName: string): string {
-    return `${this.keyPrefix}:agent-threads:${agentName}`
-  }
-
-  async listThreads(options?: {
-    agentName?: string
-    resourceId?: string
-    owners?: string[]
-    limit?: number
-    offset?: number
-  }): Promise<AgentThread[]> {
-    const {
-      agentName,
-      resourceId,
-      owners,
-      limit = 50,
-      offset = 0,
-    } = options ?? {}
-
-    // An owners constraint is an authorization boundary, so an empty list must
-    // match nothing rather than degrade to "no filter".
-    if (owners && owners.length === 0) return []
-
-    let threadIds: string[]
-
-    if (agentName) {
-      const allIds = await this.redis.smembers(this.agentThreadsKey(agentName))
-      const threadsWithScores: { id: string; score: number }[] = []
-      for (const id of allIds) {
-        const score = await this.redis.zscore(this.threadsIndexKey(), id)
-        if (score) {
-          threadsWithScores.push({ id, score: Number(score) })
-        }
-      }
-      threadsWithScores.sort((a, b) => b.score - a.score)
-      threadIds = threadsWithScores.map((t) => t.id)
-    } else {
-      threadIds = await this.redis.zrevrange(this.threadsIndexKey(), 0, -1)
-    }
-
-    // Filter before paging: slicing first would let a page of another owner's
-    // threads collapse to fewer results than requested (and, for `owners`, makes
-    // the page size leak how many foreign threads exist).
-    const matched: AgentThread[] = []
-    for (const id of threadIds) {
-      const thread = await this.getThread(id)
-      if (!thread) continue
-      if (resourceId && thread.resourceId !== resourceId) continue
-      if (
-        owners &&
-        !owners.some((owner) => isOwnedByPrincipal(thread.resourceId, owner))
-      ) {
-        continue
-      }
-      matched.push(thread)
-    }
-
-    return matched.slice(offset, offset + limit)
-  }
-
-  async getThread(threadId: string): Promise<AgentThread | null> {
-    const data = await this.redis.hgetall(this.threadKey(threadId))
-    if (!data.id) return null
-    return {
-      id: data.id,
-      resourceId: data.resourceId!,
-      title: data.title || undefined,
-      metadata: data.metadata ? JSON.parse(data.metadata) : undefined,
-      createdAt: new Date(Number(data.createdAt)),
-      updatedAt: new Date(Number(data.updatedAt)),
-    }
-  }
-
-  async getThreadMessages(threadId: string): Promise<AgentMessage[]> {
-    const entries = await this.redis.zrange(this.messagesKey(threadId), 0, '-1')
-    return entries.map((entry) => {
-      const msg = JSON.parse(entry)
-      return {
-        ...msg,
-        createdAt: new Date(msg.createdAt),
-      }
-    })
-  }
-
-  async getThreadRuns(threadId: string): Promise<AgentRunRow[]> {
-    const runIds = await this.redis.zrevrange(
-      this.threadRunsKey(threadId),
-      0,
-      -1
-    )
-
-    const runs: AgentRunRow[] = []
-    for (const runId of runIds) {
-      const data = await this.redis.hgetall(this.runKey(runId))
-      if (!data.runId) continue
-      runs.push({
-        runId: data.runId,
-        agentName: data.agentName!,
-        threadId: data.threadId!,
-        resourceId: data.resourceId!,
-        status: data.status!,
-        suspendReason: data.suspendReason || undefined,
-        missingRpcs: data.missingRpcs
-          ? JSON.parse(data.missingRpcs)
-          : undefined,
-        usageInputTokens: Number(data.usageInputTokens || 0),
-        usageOutputTokens: Number(data.usageOutputTokens || 0),
-        usageModel: data.usageModel!,
-        createdAt: new Date(Number(data.createdAt)),
-        updatedAt: new Date(Number(data.updatedAt)),
-      })
-    }
-
-    return runs
-  }
-
-  async deleteThread(threadId: string): Promise<boolean> {
-    const exists = await this.redis.exists(this.threadKey(threadId))
-    if (!exists) return false
-
-    const runIds = await this.redis.zrange(
-      this.threadRunsKey(threadId),
-      0,
-      '-1'
-    )
-
-    const keysToDelete = [
-      this.threadKey(threadId),
-      this.messagesKey(threadId),
-      this.threadRunsKey(threadId),
-    ]
-
-    for (const runId of runIds) {
-      const agentName = await this.redis.hget(this.runKey(runId), 'agentName')
-      keysToDelete.push(this.runKey(runId))
-      if (agentName) {
-        await this.redis.srem(this.agentThreadsKey(agentName), threadId)
-      }
-    }
-
-    await this.redis.zrem(this.threadsIndexKey(), threadId)
-
-    if (keysToDelete.length > 0) {
-      await this.redis.del(...keysToDelete)
-    }
-
-    return true
-  }
-
-  async getDistinctAgentNames(): Promise<string[]> {
-    const keys = await this.scanKeys(`${this.keyPrefix}:agent-threads:*`)
-    const prefix = `${this.keyPrefix}:agent-threads:`
-    return keys.map((k) => k.slice(prefix.length)).sort()
-  }
-
-  private async scanKeys(pattern: string): Promise<string[]> {
-    const keys: string[] = []
-    let cursor = '0'
-    do {
-      const [newCursor, foundKeys] = await this.redis.scan(
-        cursor,
-        'MATCH',
-        pattern,
-        'COUNT',
-        100
-      )
-      cursor = newCursor
-      keys.push(...foundKeys)
-    } while (cursor !== '0')
-    return keys
-  }
-}

package/src/redis-channel-store.ts

@@ -1,158 +0,0 @@
-import { ChannelStore } from '@pikku/core/channel'
-import type { Channel } from '@pikku/core/channel'
-import { Redis, type RedisOptions } from 'ioredis'
-
-/**
- * Redis-based implementation of ChannelStore
- *
- * Stores channel state in Redis with configurable key prefix.
- *
- * @example
- * ```typescript
- * const redis = new Redis({ host: 'localhost', port: 6379 })
- * const store = new RedisChannelStore(redis, 'myapp')
- * ```
- */
-export class RedisChannelStore extends ChannelStore {
-  private redis: Redis
-  private keyPrefix: string
-  private ownsConnection: boolean
-
-  /**
-   * @param connectionOrConfig - ioredis Redis instance or RedisOptions config
-   * @param keyPrefix - Redis key prefix (default: 'pikku')
-   */
-  constructor(
-    connectionOrConfig: Redis | RedisOptions | string,
-    keyPrefix = 'pikku'
-  ) {
-    super()
-    this.keyPrefix = keyPrefix
-
-    // Check if it's a Redis instance or config options
-    if (connectionOrConfig instanceof Redis) {
-      this.redis = connectionOrConfig
-      this.ownsConnection = false
-    } else if (typeof connectionOrConfig === 'string') {
-      // It's a connection string
-      this.redis = new Redis(connectionOrConfig)
-      this.ownsConnection = true
-    } else {
-      // It's a config object
-      this.redis = new Redis(connectionOrConfig)
-      this.ownsConnection = true
-    }
-  }
-
-  /**
-   * Initialize the store (no-op for Redis, always ready)
-   */
-  public async init(): Promise<void> {
-    // Redis doesn't require schema initialization
-    // Just verify connection works
-    await this.redis.ping()
-  }
-
-  private channelKey(channelId: string): string {
-    return `${this.keyPrefix}:channel:${channelId}`
-  }
-
-  public async addChannel({
-    channelId,
-    channelName,
-    openingData,
-  }: Channel): Promise<void> {
-    const key = this.channelKey(channelId)
-
-    await this.redis.hmset(
-      key,
-      'channelId',
-      channelId,
-      'channelName',
-      channelName,
-      'openingData',
-      JSON.stringify(openingData || {}),
-      'createdAt',
-      Date.now().toString()
-    )
-  }
-
-  public async removeChannels(channelIds: string[]): Promise<void> {
-    if (channelIds.length === 0) {
-      return
-    }
-
-    const pipeline = this.redis.pipeline()
-
-    for (const channelId of channelIds) {
-      const key = this.channelKey(channelId)
-      pipeline.del(key)
-      // Also remove from subscriptions
-      pipeline.del(`${this.keyPrefix}:subs:${channelId}`)
-    }
-
-    await pipeline.exec()
-  }
-
-  public async setPikkuUserId(
-    channelId: string,
-    pikkuUserId: string | null
-  ): Promise<void> {
-    const key = this.channelKey(channelId)
-
-    if (pikkuUserId) {
-      await this.redis.hset(key, 'pikkuUserId', pikkuUserId)
-    } else {
-      await this.redis.hdel(key, 'pikkuUserId')
-    }
-  }
-
-  public async getChannel(
-    channelId: string
-  ): Promise<Channel & { pikkuUserId?: string }> {
-    const key = this.channelKey(channelId)
-    const data = await this.redis.hgetall(key)
-
-    if (!data.channelId) {
-      throw new Error(`Channel not found: ${channelId}`)
-    }
-
-    return {
-      channelId: data.channelId!,
-      channelName: data.channelName!,
-      openingData: data.openingData ? JSON.parse(data.openingData) : {},
-      pikkuUserId: data.pikkuUserId || undefined,
-    }
-  }
-
-  public async setState(channelId: string, state: unknown): Promise<void> {
-    const key = this.channelKey(channelId)
-    await this.redis.hset(key, 'state', JSON.stringify(state ?? null))
-  }
-
-  public async getState(channelId: string): Promise<unknown | undefined> {
-    const key = this.channelKey(channelId)
-    const raw = await this.redis.hget(key, 'state')
-    if (!raw) return undefined
-    try {
-      const parsed = JSON.parse(raw)
-      return parsed ?? undefined
-    } catch {
-      return undefined
-    }
-  }
-
-  public async clearState(channelId: string): Promise<void> {
-    const key = this.channelKey(channelId)
-    await this.redis.hdel(key, 'state')
-  }
-
-  /**
-   * Close the Redis connection if owned by this store
-   */
-  public async close(): Promise<void> {
-    if (this.ownsConnection) {
-      await this.redis.quit()
-    }
-  }
-}

package/src/redis-deployment-service.ts

@@ -1,171 +0,0 @@
-import { buildRemoteHeaders } from '@pikku/core/remote'
-import type {
-  DeploymentService,
-  DeploymentServiceConfig,
-  DeploymentConfig,
-} from '@pikku/core/services'
-import type { JWTService } from '@pikku/core/services'
-import type { SecretService } from '@pikku/core/services'
-import { getAllFunctionNames } from '@pikku/core/function'
-import { Redis, type RedisOptions } from 'ioredis'
-
-export class RedisDeploymentService implements DeploymentService {
-  private redis: Redis
-  private keyPrefix: string
-  private ownsConnection: boolean
-  private heartbeatTimer?: ReturnType<typeof setInterval>
-  private deploymentConfig?: DeploymentConfig
-  private heartbeatInterval: number
-  private heartbeatTtl: number
-
-  constructor(
-    config: DeploymentServiceConfig,
-    connectionOrConfig: Redis | RedisOptions | string,
-    keyPrefix = 'pikku',
-    private jwt?: JWTService,
-    private secrets?: SecretService
-  ) {
-    this.heartbeatInterval = config.heartbeatInterval ?? 10000
-    this.heartbeatTtl = config.heartbeatTtl ?? 30000
-    this.keyPrefix = keyPrefix
-
-    if (connectionOrConfig instanceof Redis) {
-      this.redis = connectionOrConfig
-      this.ownsConnection = false
-    } else if (typeof connectionOrConfig === 'string') {
-      this.redis = new Redis(connectionOrConfig)
-      this.ownsConnection = true
-    } else {
-      this.redis = new Redis(connectionOrConfig)
-      this.ownsConnection = true
-    }
-  }
-
-  private deploymentKey(deploymentId: string): string {
-    return `${this.keyPrefix}:deployment:${deploymentId}`
-  }
-
-  private functionsIndexKey(funcName: string): string {
-    return `${this.keyPrefix}:fn:${funcName}`
-  }
-
-  public async init(): Promise<void> {}
-
-  async start(config: DeploymentConfig): Promise<void> {
-    const functions = config.functions ?? getAllFunctionNames()
-    this.deploymentConfig = { ...config, functions }
-    const ttlSeconds = Math.ceil(this.heartbeatTtl / 1000)
-    const expiryScore = Date.now() + this.heartbeatTtl
-
-    const pipeline = this.redis.pipeline()
-
-    pipeline.hset(this.deploymentKey(config.deploymentId), {
-      endpoint: config.endpoint,
-      functions: JSON.stringify(functions),
-    })
-    pipeline.expire(this.deploymentKey(config.deploymentId), ttlSeconds)
-
-    for (const fn of functions) {
-      pipeline.zadd(
-        this.functionsIndexKey(fn),
-        expiryScore,
-        config.deploymentId
-      )
-    }
-
-    await pipeline.exec()
-
-    this.heartbeatTimer = setInterval(
-      () => this.sendHeartbeat(),
-      this.heartbeatInterval
-    )
-  }
-
-  async stop(): Promise<void> {
-    if (this.heartbeatTimer) {
-      clearInterval(this.heartbeatTimer)
-      this.heartbeatTimer = undefined
-    }
-
-    if (this.deploymentConfig) {
-      const { deploymentId, functions } = this.deploymentConfig
-      const pipeline = this.redis.pipeline()
-
-      pipeline.del(this.deploymentKey(deploymentId))
-      for (const fn of functions!) {
-        pipeline.zrem(this.functionsIndexKey(fn), deploymentId)
-      }
-
-      await pipeline.exec()
-    }
-
-    if (this.ownsConnection) {
-      await this.redis.quit()
-    }
-  }
-
-  async invoke(
-    funcName: string,
-    data: unknown,
-    session?: unknown,
-    traceId?: string
-  ): Promise<unknown> {
-    const headers = await buildRemoteHeaders(
-      this.jwt,
-      this.secrets,
-      funcName,
-      session,
-      traceId
-    )
-    const indexKey = this.functionsIndexKey(funcName)
-    const now = Date.now()
-
-    await this.redis.zremrangebyscore(indexKey, '-inf', now)
-    const deploymentIds = await this.redis.zrangebyscore(indexKey, now, '+inf')
-
-    let endpoint: string | null = null
-    for (const deploymentId of deploymentIds) {
-      endpoint = await this.redis.hget(
-        this.deploymentKey(deploymentId),
-        'endpoint'
-      )
-      if (endpoint) break
-    }
-
-    if (!endpoint) {
-      throw new Error(`No deployment found for function '${funcName}'`)
-    }
-
-    const url = `${endpoint}/remote/rpc/${encodeURIComponent(funcName)}`
-    const response = await fetch(url, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify({ data }),
-    })
-    if (!response.ok) {
-      throw new Error(
-        `Remote RPC call to '${funcName}' failed: ${response.status}`
-      )
-    }
-    return response.json()
-  }
-
-  private async sendHeartbeat(): Promise<void> {
-    if (!this.deploymentConfig) return
-
-    const { deploymentId, functions } = this.deploymentConfig
-    const ttlSeconds = Math.ceil(this.heartbeatTtl / 1000)
-    const expiryScore = Date.now() + this.heartbeatTtl
-
-    try {
-      const pipeline = this.redis.pipeline()
-      pipeline.expire(this.deploymentKey(deploymentId), ttlSeconds)
-      for (const fn of functions!) {
-        pipeline.zadd(this.functionsIndexKey(fn), expiryScore, deploymentId)
-      }
-      await pipeline.exec()
-    } catch {
-      // Heartbeat failed, will retry on next interval
-    }
-  }
-}

package/src/redis-eventhub-store.ts

@@ -1,104 +0,0 @@
-import type { EventHubStore } from '@pikku/core/channel'
-import { Redis, type RedisOptions } from 'ioredis'
-
-/**
- * Redis-based implementation of EventHubStore
- *
- * Manages pub/sub topic subscriptions for channels in Redis.
- *
- * @example
- * ```typescript
- * const redis = new Redis({ host: 'localhost', port: 6379 })
- * const store = new RedisEventHubStore(redis, 'myapp')
- * await store.subscribe('user.123', channelId)
- * ```
- */
-export class RedisEventHubStore implements EventHubStore {
-  private redis: Redis
-  private keyPrefix: string
-  private ownsConnection: boolean
-
-  /**
-   * @param connectionOrConfig - ioredis Redis instance or RedisOptions config
-   * @param keyPrefix - Redis key prefix (default: 'pikku')
-   */
-  constructor(
-    connectionOrConfig: Redis | RedisOptions | string,
-    keyPrefix = 'pikku'
-  ) {
-    this.keyPrefix = keyPrefix
-
-    // Check if it's a Redis instance or config options
-    if (connectionOrConfig instanceof Redis) {
-      this.redis = connectionOrConfig
-      this.ownsConnection = false
-    } else if (typeof connectionOrConfig === 'string') {
-      // It's a connection string
-      this.redis = new Redis(connectionOrConfig)
-      this.ownsConnection = true
-    } else {
-      // It's a config object
-      this.redis = new Redis(connectionOrConfig)
-      this.ownsConnection = true
-    }
-  }
-
-  /**
-   * Initialize the store (no-op for Redis, always ready)
-   */
-  public async init(): Promise<void> {
-    // Redis doesn't require schema initialization
-    await this.redis.ping()
-  }
-
-  private topicKey(topic: string): string {
-    return `${this.keyPrefix}:topic:${topic}`
-  }
-
-  private channelSubsKey(channelId: string): string {
-    return `${this.keyPrefix}:subs:${channelId}`
-  }
-
-  public async getChannelIdsForTopic(topic: string): Promise<string[]> {
-    const key = this.topicKey(topic)
-    return await this.redis.smembers(key)
-  }
-
-  public async subscribe(topic: string, channelId: string): Promise<boolean> {
-    const topicKey = this.topicKey(topic)
-    const subsKey = this.channelSubsKey(channelId)
-
-    // Add channelId to topic set and topic to channel's subscription set
-    const pipeline = this.redis.pipeline()
-    pipeline.sadd(topicKey, channelId)
-    pipeline.sadd(subsKey, topic)
-
-    await pipeline.exec()
-
-    return true
-  }
-
-  public async unsubscribe(topic: string, channelId: string): Promise<boolean> {
-    const topicKey = this.topicKey(topic)
-    const subsKey = this.channelSubsKey(channelId)
-
-    // Remove channelId from topic set and topic from channel's subscription set
-    const pipeline = this.redis.pipeline()
-    pipeline.srem(topicKey, channelId)
-    pipeline.srem(subsKey, topic)
-
-    const results = await pipeline.exec()
-
-    // Check if the channel was actually in the topic set
-    return (results![0]![1] as number) > 0
-  }
-
-  /**
-   * Close the Redis connection if owned by this store
-   */
-  public async close(): Promise<void> {
-    if (this.ownsConnection) {
-      await this.redis.quit()
-    }
-  }
-}