a869f77070
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
80 lines
2.3 KiB
Markdown
80 lines
2.3 KiB
Markdown
# 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`:
|
|
|
|
```typescript
|
|
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.
|