Files

Michal a869f77070 merge: AgentProject membership — the junction is now load-bearing

Merges feat/agent-project-membership (task 166/152). An agent can finally join
many projects: membership routes, per-membership role and optional brain
override, chat resolving context from the membership, and CLI attach-agent /
detach-agent / get memberships. The legacy Agent.projectId fallback is kept for
this release as the schema comment promises.

Conflict resolved in main.ts: that branch added its RBAC case to
mapUrlToPermission inline, while this branch had extracted the function to
middleware/url-permission.ts so it could be tested. Kept the extraction and
ported the case into it — joining a team is `edit:agents:<name>`, not
`create:agents`, which is the authority to mint a whole agent.

Also fixes something the extraction makes possible. security.test.ts contained a
hand-copied reproduction of mapUrlToPermission, because main.ts self-invokes
main() and nothing in it was importable. A security test asserting against a
copy stops testing the system the moment the real one changes, and this copy had
already drifted. It now imports the real function; all 18 assertions still pass,
against the code that actually runs.

Local: build clean, workspace 2550 passed, lint unchanged at 794 errors.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01N4wNHWf7xSwnZCWpJcyv9p

2026-08-09 23:34:18 +01:00

2.3 KiB

Raw Blame History

Task ID: 98

Title: Implement Persistent File Cache for Stages

Status: done

Dependencies: 73 ✓

Priority: high

Description: Extend CacheProvider with file-based persistence in ~/.mcpctl/cache/proxymodel/ for cross-session caching.

Details:

Create src/mcplocal/src/proxymodel/file-cache.ts:

import { mkdir, readFile, writeFile, readdir, stat, unlink } from 'fs/promises';
import { join } from 'path';
import { createHash } from 'crypto';
import type { CacheProvider } from './types';

const CACHE_DIR = join(process.env.HOME ?? '', '.mcpctl', 'cache', 'proxymodel');

export class FileCacheProvider implements CacheProvider {
  private memCache = new Map<string, string>();
  private maxSizeBytes: number;
  
  constructor(options: { maxSizeBytes?: number } = {}) {
    this.maxSizeBytes = options.maxSizeBytes ?? 100 * 1024 * 1024; // 100MB default
  }
  
  hash(content: string): string {
    return createHash('sha256').update(content).digest('hex').slice(0, 16);
  }
  
  private keyToPath(key: string): string {
    const safeKey = key.replace(/[^a-zA-Z0-9-_]/g, '_');
    return join(CACHE_DIR, safeKey);
  }
  
  async get(key: string): Promise<string | null> {
    // Check memory first
    if (this.memCache.has(key)) return this.memCache.get(key)!;
    
    // Check file
    try {
      const content = await readFile(this.keyToPath(key), 'utf-8');
      this.memCache.set(key, content); // Warm memory cache
      return content;
    } catch {
      return null;
    }
  }
  
  async set(key: string, value: string): Promise<void> {
    await mkdir(CACHE_DIR, { recursive: true });
    this.memCache.set(key, value);
    await writeFile(this.keyToPath(key), value);
    await this.enforceMaxSize();
  }
  
  async getOrCompute(key: string, compute: () => Promise<string>): Promise<string> {
    const cached = await this.get(key);
    if (cached !== null) return cached;
    const value = await compute();
    await this.set(key, value);
    return value;
  }
  
  private async enforceMaxSize(): Promise<void> {
    // LRU eviction based on file mtime when cache exceeds maxSizeBytes
  }
}

Test Strategy:

Unit tests: file-based persistence survives process restart, memory cache is warmed on file read, LRU eviction works when size exceeded, concurrent access is safe. Integration test with real filesystem.

2.3 KiB Raw Blame History

Task ID: 98

2.3 KiB

Raw Blame History