Class FileLearnSessionCacheStore

cli/src/mcp/cache.ts:45–129

}

class FileLearnSessionCacheStore implements LearnSessionCacheStore {
  private readonly cacheFilePath: string;
  private readonly ttlMs: number;
  private readonly now: () => number;

  constructor(options: FileLearnSessionCacheStoreOptions) {
    this.cacheFilePath = options.cacheFilePath ?? getDefaultCacheFilePath();
    this.ttlMs = options.ttlMs ?? DEFAULT_CACHE_TTL_MS;
    this.now = options.now ?? Date.now;
  }

  async read(endpoint: string): Promise<LearnSessionCacheValue | undefined> {
    const normalizedEndpoint = normalizeEndpoint(endpoint);
    const cache = await this.readCacheFile();
    const entry = cache.entries[normalizedEndpoint];

    if (!entry) {
      return undefined;
    }

    if (new Date(entry.expiresAt).getTime() <= this.now()) {
      delete cache.entries[normalizedEndpoint];
      await this.writeCacheFile(cache);
      return undefined;
    }

    return entry;
  }

  async write(value: { endpoint: string; sessionId?: string; tools?: ListedTool[] }): Promise<LearnSessionCacheValue> {
    const normalizedEndpoint = normalizeEndpoint(value.endpoint);
    const cache = await this.readCacheFile();
    const storedValue: LearnSessionCacheValue = {
      endpoint: normalizedEndpoint,
      sessionId: value.sessionId,
      tools: value.tools ? [...value.tools] : undefined,
      updatedAt: new Date(this.now()).toISOString(),
      expiresAt: new Date(this.now() + this.ttlMs).toISOString(),
    };

    cache.entries[normalizedEndpoint] = storedValue;
    await this.writeCacheFile(cache);
    return storedValue;
  }

  async clear(endpoint: string): Promise<void> {
    const normalizedEndpoint = normalizeEndpoint(endpoint);
    const cache = await this.readCacheFile();

    if (!(normalizedEndpoint in cache.entries)) {
      return;
    }

    delete cache.entries[normalizedEndpoint];

    if (Object.keys(cache.entries).length === 0) {
      await rm(this.cacheFilePath, { force: true }).catch(() => undefined);
      return;