@cachly-dev/mcp-server 0.10.27 → 0.10.40

package/src/__tests__/e2e/provisioning.test.ts

@@ -0,0 +1,128 @@
+/**
+ * E2E: Provisioning flow
+ *
+ * Tests the full instance lifecycle:
+ *   create → poll until active (or timeout) → connect → delete
+ *
+ * ⚠️  This test creates a real instance and WILL be billed if not deleted.
+ *     It always cleans up in afterAll, even on failure.
+ *
+ * Skipped if E2E_SKIP_SLOW=true.
+ *
+ * Requires: E2E_JWT
+ * Run: npx vitest run src/__tests__/e2e/provisioning.test.ts --reporter=verbose
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { cfg, requireAuth, apiGet, apiPost } from './config.js';
+
+beforeAll(() => {
+  requireAuth();
+  if (cfg.skipSlow) {
+    console.log('Skipping provisioning tests (E2E_SKIP_SLOW=true)');
+  }
+});
+
+let createdInstanceId: string | null = null;
+
+afterAll(async () => {
+  if (!createdInstanceId) return;
+  try {
+    const res = await fetch(`${cfg.apiUrl}/api/v1/instances/${createdInstanceId}`, {
+      method: 'DELETE',
+      headers: { Authorization: `Bearer ${cfg.jwt}` },
+    });
+    console.log(`Cleanup: deleted instance ${createdInstanceId} → ${res.status}`);
+  } catch (e) {
+    console.warn(`Cleanup failed for ${createdInstanceId}:`, e);
+  }
+});
+
+describe('Instance provisioning lifecycle', () => {
+  it.skipIf(cfg.skipSlow)('POST /api/v1/instances creates a new free instance', async () => {
+    const { status, body } = await apiPost('/api/v1/instances', {
+      name: `e2e-test-${Date.now()}`,
+      tier: 'free',
+    });
+    expect([200, 201]).toContain(status);
+    const inst = body as Record<string, unknown>;
+    expect(typeof inst.id).toBe('string');
+    expect(inst.status).toMatch(/^(provisioning|active)$/);
+    createdInstanceId = inst.id as string;
+  });
+
+  it.skipIf(cfg.skipSlow)('instance status transitions from provisioning → active within 5 min', async () => {
+    if (!createdInstanceId) return;
+
+    const maxWaitMs = 5 * 60 * 1000; // 5 minutes
+    const pollMs    = 10_000;         // poll every 10 seconds
+    const start     = Date.now();
+    let status      = 'provisioning';
+
+    while (Date.now() - start < maxWaitMs) {
+      await new Promise((r) => setTimeout(r, pollMs));
+      const { body } = await apiGet(`/api/v1/instances/${createdInstanceId}`);
+      status = (body as Record<string, unknown>).status as string;
+      console.log(`  [${Math.round((Date.now() - start) / 1000)}s] status: ${status}`);
+      if (status === 'active') break;
+      if (status === 'failed')  break;
+    }
+
+    expect(status).toBe('active');
+  }, 6 * 60 * 1000); // vitest timeout: 6 min
+
+  it.skipIf(cfg.skipSlow)('active instance returns valid connection details', async () => {
+    if (!createdInstanceId) return;
+    const { status, body } = await apiGet(`/api/v1/instances/${createdInstanceId}/connection`);
+    expect(status).toBe(200);
+    const conn = body as Record<string, unknown>;
+    expect(typeof conn.host).toBe('string');
+    expect(Number(conn.port)).toBeGreaterThan(0);
+    expect(typeof conn.password).toBe('string');
+  });
+
+  it.skipIf(cfg.skipSlow)('can PING the provisioned Redis', async () => {
+    if (!createdInstanceId) return;
+    const { body } = await apiGet(`/api/v1/instances/${createdInstanceId}/connection`);
+    const conn = body as Record<string, unknown>;
+
+    const { Redis: RedisClass } = await import('ioredis');
+    const r = new RedisClass({
+      host: conn.host as string,
+      port: Number(conn.port),
+      password: conn.password as string,
+      tls: cfg.redisTls ? {} : undefined,
+      connectTimeout: 8000,
+      lazyConnect: true,
+    });
+    try {
+      await r.connect();
+      expect(await r.ping()).toBe('PONG');
+    } finally {
+      await r.quit();
+    }
+  });
+});
+
+describe('Provisioning status — failed instance handling', () => {
+  it('failed status returns meaningful error (not 500) from connection endpoint', async () => {
+    // We use a known-bad UUID to simulate a missing/failed instance
+    const { status } = await apiGet('/api/v1/instances/00000000-0000-0000-0000-000000000000/connection');
+    // Should be a client error (4xx), never a server error (5xx)
+    expect(status).toBeGreaterThanOrEqual(400);
+    expect(status).toBeLessThan(500);
+  });
+});
+
+describe('Auto-provision via /instances/auto', () => {
+  it.skipIf(cfg.skipSlow)('POST /api/v1/instances/auto returns instance id', async () => {
+    const { status, body } = await apiPost('/api/v1/instances/auto', {});
+    // 200 = existing instance returned
+    // 201 = new instance created
+    // 409 = already has an instance (also fine)
+    expect([200, 201, 409]).toContain(status);
+    if (status !== 409) {
+      expect(typeof (body as Record<string, unknown>).id).toBe('string');
+    }
+  });
+});

package/src/handlers/advanced.ts

@@ -4,13 +4,13 @@ import { calculateConfidence, confidenceBadge, CONFIDENCE_STALE_VALUE, CONFIDENC
 import { ckgSlug, ckgUpdateEdge } from '../ckg.js';
 import type { CKGEdge, CKGNode } from '../ckg.js';
 import { keywordSearch } from '../search.js';
+import { safeJsonParse } from '../utils.js';
 
 type GetConnection = (instanceId: string) => Promise<Redis>;
 type ApiFetch = <T>(path: string, options?: RequestInit) => Promise<T>;
 
 export const ADVANCED_TOOL_NAMES = new Set([
   'memory_consolidate', 'brain_diff', 'causal_trace', 'knowledge_decay', 'autopilot',
-  'brain_stats', 'pin_lesson', 'unpin_lesson',
 ]);
 
 export async function handleAdvancedTool(
@@ -46,7 +46,8 @@ export async function handleAdvancedTool(
       for (const k of lessonKeys) {
         const raw = await redis.get(k);
         if (!raw) continue;
-        try { lessons.set(k, JSON.parse(raw) as Lesson); } catch { /* skip malformed */ }
+        const lesson = safeJsonParse<Lesson | null>(raw, null);
+        if (lesson) lessons.set(k, lesson);
       }
 
       // Detect duplicates: same topic prefix (e.g. deploy:api vs deploy:api-v2)
@@ -104,25 +105,6 @@ export async function handleAdvancedTool(
         for (const k of stale) {
           await redis.expire(k, 86400 * 30);
         }
-        // Auto-unpin lessons whose lesson key was deleted (merged or stale-expired)
-        // Also unpin if the lesson outcome changed to 'failure' (auto-pin only fires on success/partial)
-        const pinKeys: string[] = [];
-        const pinStream = redis.scanStream({ match: 'cachly:lesson:pin:*', count: 100 });
-        await new Promise<void>((res, rej) => { pinStream.on('data', (b: string[]) => pinKeys.push(...b)); pinStream.on('end', res); pinStream.on('error', rej); });
-        let unpinned = 0;
-        for (const pk of pinKeys) {
-          const pinnedTopic = pk.replace('cachly:lesson:pin:', '');
-          const lessonStillExists = await redis.exists(`cachly:lesson:best:${pinnedTopic}`);
-          if (!lessonStillExists) { await redis.del(pk); unpinned++; continue; }
-          const raw = await redis.get(`cachly:lesson:best:${pinnedTopic}`);
-          if (raw) {
-            try {
-              const l = JSON.parse(raw) as { outcome: string };
-              if (l.outcome === 'failure') { await redis.del(pk); unpinned++; }
-            } catch { /* skip */ }
-          }
-        }
-        if (unpinned > 0) stale.push(...Array(unpinned).fill('__unpin_placeholder__')); // just for count
       }
 
       const lines = [
@@ -186,8 +168,9 @@ export async function handleAdvancedTool(
       for (const k of lessonKeys) {
         const raw = await redis.get(k);
         if (!raw) continue;
-        try {
-          const l = JSON.parse(raw) as Lesson;
+        {
+          const l = safeJsonParse<Lesson | null>(raw, null);
+          if (!l) continue;
           const ts = new Date(l.ts).getTime();
           if (ts >= sinceMs) {
             // Check history to determine add vs update
@@ -201,7 +184,7 @@ export async function handleAdvancedTool(
             // lessons with recalls as "active"
             recalled.push(l);
           }
-        } catch { /* skip */ }
+        }
       }
 
       const sinceLabel = match ? `last ${since}` : new Date(sinceMs).toLocaleDateString('de-DE');
@@ -235,10 +218,10 @@ export async function handleAdvancedTool(
       for (const rk of resolutionKeys) {
         const rr = await redis.get(rk);
         if (!rr) continue;
-        try {
-          const rn = JSON.parse(rr) as { topic?: string; resolution?: string; ts?: string };
-          if (rn.ts && new Date(rn.ts).getTime() >= sinceMs) recentResolutions.push({ topic: rn.topic ?? rk, resolution: rn.resolution ?? 'unknown', ts: rn.ts });
-        } catch { /* skip */ }
+        {
+          const rn = safeJsonParse<{ topic?: string; resolution?: string; ts?: string } | null>(rr, null);
+          if (rn?.ts && new Date(rn.ts).getTime() >= sinceMs) recentResolutions.push({ topic: rn.topic ?? rk, resolution: rn.resolution ?? 'unknown', ts: rn.ts });
+        }
       }
       if (recentResolutions.length > 0) {
         lines.push(`🗳️ **MADC Resolutions** (${recentResolutions.length} contested beliefs resolved):`);
@@ -258,8 +241,10 @@ export async function handleAdvancedTool(
 
       // 3. FedBrain transfers received in window
       const fedHistRaw = await redis.lrange('cachly:fedbrain:federations', -20, -1);
-      const recentFeds = fedHistRaw.map(r => { try { return JSON.parse(r) as { source: string; domain: string; transferred_at: string; nodes: number; edges: number }; } catch { return null; } })
-        .filter(f => f && new Date(f!.transferred_at).getTime() >= sinceMs) as Array<{ source: string; domain: string; transferred_at: string; nodes: number; edges: number }>;
+      type FedEntry = { source: string; domain: string; transferred_at: string; nodes: number; edges: number };
+      const recentFeds = fedHistRaw
+        .map(r => safeJsonParse<FedEntry | null>(r, null))
+        .filter((f): f is FedEntry => f !== null && new Date(f.transferred_at).getTime() >= sinceMs);
       if (recentFeds.length > 0) {
         lines.push(`🧠 **FedBrain transfers received (${recentFeds.length}):**`);
         for (const f of recentFeds.slice(0, 3)) {
@@ -302,27 +287,30 @@ export async function handleAdvancedTool(
           for (const nodeKey of nodeKeys.slice(0, 10)) {
             const nodeRaw = await redis.get(nodeKey);
             if (!nodeRaw) continue;
-            const node: CKGNode = JSON.parse(nodeRaw);
+            const node = safeJsonParse<CKGNode | null>(nodeRaw, null);
+            if (!node) continue;
             // Get edges from this node
             const edgeKeys = await redis.smembers(`cachly:ckg:idx:from:${node.id}`);
             for (const ek of edgeKeys.slice(0, 20)) {
               const edgeRaw = await redis.get(ek);
               if (!edgeRaw) continue;
-              const edge: CKGEdge = JSON.parse(edgeRaw);
+              const edge = safeJsonParse<CKGEdge | null>(edgeRaw, null);
+              if (!edge) continue;
               if (edge.edgeType !== 'fixes' && edge.edgeType !== 'requires') continue;
               // Find lesson for this concept
               const lessonRaw = await redis.get(`cachly:lesson:best:${edge.from.replace(/-/g, ':').replace(/^fix:/, 'fix:')}`);
-              const lesson = lessonRaw ? JSON.parse(lessonRaw) : undefined;
-              ckgResults.push({ conceptId: node.id, edge, lesson });
+              const lesson = lessonRaw ? safeJsonParse<{ topic: string; what_worked?: string; ts: string; outcome: string; recall_count?: number; severity?: string } | null>(lessonRaw, null) ?? undefined : undefined;
+              ckgResults.push({ conceptId: node.id, edge, lesson: lesson ?? undefined });
             }
           }
           for (const ek of [...fromKeys, ...toKeys].slice(0, 20)) {
             const edgeRaw = await redis.get(ek);
             if (!edgeRaw) continue;
-            const edge: CKGEdge = JSON.parse(edgeRaw);
+            const edge = safeJsonParse<CKGEdge | null>(edgeRaw, null);
+            if (!edge) continue;
             const lessonRaw = await redis.get(`cachly:lesson:best:${edge.from}`);
-            const lesson = lessonRaw ? JSON.parse(lessonRaw) : undefined;
-            ckgResults.push({ conceptId: edge.from, edge, lesson });
+            const lesson = lessonRaw ? safeJsonParse<{ topic: string; what_worked?: string; ts: string; outcome: string; recall_count?: number; severity?: string } | null>(lessonRaw, null) ?? undefined : undefined;
+            ckgResults.push({ conceptId: edge.from, edge, lesson: lesson ?? undefined });
           }
         }
       } catch { /* CKG traversal non-critical */ }
@@ -356,14 +344,15 @@ export async function handleAdvancedTool(
       for (const k of lessonKeys) {
         const raw = await redis.get(k);
         if (!raw) continue;
-        try {
-          const l = JSON.parse(raw) as Lesson;
+        {
+          const l = safeJsonParse<Lesson | null>(raw, null);
+          if (!l) continue;
           if (filterTags.length > 0 && !(l.tags ?? []).some((t: string) => filterTags.includes(t))) continue;
           const haystack = [l.topic, l.what_failed ?? '', l.what_worked ?? '', l.context ?? '']
             .join(' ').toLowerCase();
           const score = tokens.reduce((s, t) => s + (haystack.includes(t) ? 1 : 0), 0);
           if (score > 0) scored.push({ score, lesson: l, key: k });
-        } catch { /* skip */ }
+        }
       }
       scored.sort((a, b) => b.score - a.score);
       const chain = scored.slice(0, max_depth);
@@ -440,6 +429,10 @@ export async function handleAdvancedTool(
           lines.push(topSolution.what_worked.slice(0, 500));
           lines.push(`\`\`\``);
           lines.push('');
+
+          // Track estimated time saved — causal_trace finding a known fix is worth 1-4h
+          const savedMins = topSolution.severity === 'critical' ? 240 : topSolution.severity === 'major' ? 120 : 60;
+          redis.incrbyfloat(`cachly:stats:time_saved_mins:${instance_id}`, savedMins).catch(() => {});
         }
       }
 
@@ -472,8 +465,9 @@ export async function handleAdvancedTool(
       for (const k of lessonKeys) {
         const raw = await redis.get(k);
         if (!raw) continue;
-        try {
-          const l = JSON.parse(raw) as Lesson;
+        {
+          const l = safeJsonParse<Lesson | null>(raw, null);
+          if (!l) continue;
           const ageMs = now - new Date(l.ts).getTime();
           if (ageMs < minAgeMs) continue;
           const age_days = Math.floor(ageMs / 86400000);
@@ -490,7 +484,7 @@ export async function handleAdvancedTool(
           const confidence = Math.min(100, Math.max(0, base + recallBoost + outcomePenalty));
 
           scores.push({ topic: l.topic, confidence, age_days, recalls, outcome: l.outcome });
-        } catch { /* skip */ }
+        }
       }
 
       // Sort by lowest confidence first
@@ -547,12 +541,6 @@ export async function handleAdvancedTool(
 - **Window opens** → call \`session_start(instance_id="${instance_id}", focus="<today's goal>")\`
 - **Bug fixed / deployed / discovered** → call \`learn_from_attempts(instance_id="${instance_id}", topic="fix:<area>", outcome="success", what_worked="...")\`
 - **Window closes** → call \`session_end(instance_id="${instance_id}", summary="...", files_changed=[...])\`
-
-### New team member setup:
-\`\`\`bash
-npx @cachly-dev/init
-\`\`\`
-Run once — auto-detects all AI editors and gives instant full context.
 `;
 
       const full = `## Cachly AI Brain — Autopilot for ${project_name}
@@ -624,22 +612,9 @@ smart_recall(
 
 ---
 
-## 👋 New team member?
-
-\`\`\`bash
-npx @cachly-dev/init
-\`\`\`
-
-Run once — auto-detects Claude Code, Cursor, Copilot, Windsurf, Continue and writes all MCP configs. Free, no credit card.
-
-Demo: [cachly.dev](https://cachly.dev)
-
----
-
 *Cachly v0.6 · Generated ${new Date().toISOString().slice(0, 10)}*
 `;
 
-
       const content = style === 'minimal' ? minimal : full;
       const filename = editor === 'copilot'
         ? '.github/copilot-instructions.md'
@@ -668,161 +643,6 @@ Demo: [cachly.dev](https://cachly.dev)
       ].join('\n');
     }
 
-    // ── brain_stats ─────────────────────────────────────────────────────────
-    case 'brain_stats': {
-      const { instance_id } = args as { instance_id: string };
-      const redis = await getConnection(instance_id);
-
-      // Lessons
-      const lessonKeys: string[] = [];
-      const lStream = redis.scanStream({ match: 'cachly:lesson:best:*', count: 200 });
-      await new Promise<void>((res, rej) => { lStream.on('data', (b: string[]) => lessonKeys.push(...b)); lStream.on('end', res); lStream.on('error', rej); });
-
-      type LessonMeta = { topic: string; outcome: string; ts: string; severity?: string; recall_count?: number };
-      const lessons: LessonMeta[] = [];
-      if (lessonKeys.length > 0) {
-        const raws = await redis.mget(...lessonKeys);
-        for (const r of raws) {
-          if (!r) continue;
-          try { lessons.push(JSON.parse(r) as LessonMeta); } catch { /* skip */ }
-        }
-      }
-
-      // Context entries
-      let ctxCount = 0;
-      const ctxStream = redis.scanStream({ match: 'cachly:ctx:*', count: 200 });
-      await new Promise<void>((res, rej) => {
-        ctxStream.on('data', (b: string[]) => { ctxCount += (b as string[]).filter(k => !k.endsWith(':meta')).length; });
-        ctxStream.on('end', res); ctxStream.on('error', rej);
-      });
-
-      // Roadmap items
-      let roadmapOpen = 0; let roadmapDone = 0;
-      try {
-        const rm = await redis.hgetall(`cachly:roadmap:${instance_id}`);
-        for (const v of Object.values(rm ?? {})) {
-          try {
-            const item = JSON.parse(v as string) as { status: string };
-            if (item.status === 'done') roadmapDone++;
-            else if (['planned', 'in-progress', 'blocked'].includes(item.status)) roadmapOpen++;
-          } catch { /* skip */ }
-        }
-      } catch { /* non-critical */ }
-
-      // Pinned lessons
-      const pinKeys: string[] = [];
-      const pStream = redis.scanStream({ match: 'cachly:lesson:pin:*', count: 100 });
-      await new Promise<void>((res, rej) => { pStream.on('data', (b: string[]) => pinKeys.push(...b)); pStream.on('end', res); pStream.on('error', rej); });
-      const pinnedTopics = pinKeys.map(k => k.replace('cachly:lesson:pin:', ''));
-
-      // Streak
-      let streakDays = 0;
-      try {
-        const sr = await redis.get('cachly:streak:current');
-        if (sr) streakDays = (JSON.parse(sr) as { days: number }).days;
-      } catch { /* skip */ }
-
-      // Last session
-      let lastSessionSummary = 'none yet';
-      let lastSessionAgo = '';
-      try {
-        const lsr = await redis.get('cachly:session:last');
-        if (lsr) {
-          const ls = JSON.parse(lsr) as { summary: string; ts: string };
-          const ago = Math.round((Date.now() - new Date(ls.ts).getTime()) / 60000);
-          lastSessionAgo = ago < 60 ? `${ago}m ago` : ago < 1440 ? `${Math.round(ago / 60)}h ago` : `${Math.round(ago / 1440)}d ago`;
-          lastSessionSummary = ls.summary;
-        }
-      } catch { /* skip */ }
-
-      // Crystal
-      let crystalLabel = '';
-      try {
-        const cr = await redis.get('cachly:crystal:latest');
-        if (cr) crystalLabel = (JSON.parse(cr) as { label: string }).label;
-      } catch { /* skip */ }
-
-      // Top topics
-      const topicFreq = new Map<string, number>();
-      for (const l of lessons) {
-        const cat = l.topic.split(':')[0] ?? 'other';
-        topicFreq.set(cat, (topicFreq.get(cat) ?? 0) + 1);
-      }
-      const topTopics = [...topicFreq.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5);
-
-      // Outcomes
-      const successCount = lessons.filter(l => l.outcome === 'success').length;
-      const failCount = lessons.filter(l => l.outcome === 'failure').length;
-      const totalRecalls = lessons.reduce((s, l) => s + (l.recall_count ?? 0), 0);
-
-      const lines: string[] = [
-        '🧠 **Brain Stats**',
-        '',
-        `📚 **Lessons:** ${lessons.length} (✅ ${successCount} success · ❌ ${failCount} open · recalled ${totalRecalls}×)`,
-        `📁 **Context:** ${ctxCount} entries`,
-        `🗺️ **Roadmap:** ${roadmapOpen} open · ${roadmapDone} done`,
-        `🔥 **Streak:** ${streakDays > 0 ? `${streakDays} day${streakDays > 1 ? 's' : ''}` : 'no streak yet'}`,
-        '',
-      ];
-
-      if (pinnedTopics.length > 0) {
-        lines.push(`📌 **Pinned lessons (${pinnedTopics.length}):** ${pinnedTopics.map(t => `\`${t}\``).join(' · ')}`);
-        lines.push('');
-      }
-
-      if (topTopics.length > 0) {
-        lines.push('📊 **Top knowledge domains:**');
-        for (const [cat, count] of topTopics) {
-          lines.push(`  · ${cat.padEnd(20)} ${count} lesson${count > 1 ? 's' : ''}`);
-        }
-        lines.push('');
-      }
-
-      if (lastSessionSummary !== 'none yet') {
-        lines.push(`📅 **Last session** (${lastSessionAgo}): ${lastSessionSummary}`);
-        lines.push('');
-      }
-      if (crystalLabel) {
-        lines.push(`💎 **Memory Crystal:** ${crystalLabel}`);
-        lines.push('');
-      }
-
-      lines.push('💡 `brain_doctor` for health recommendations · `brain_diff(since="7d")` for what changed');
-      return lines.join('\n');
-    }
-
-    // ── pin_lesson ──────────────────────────────────────────────────────────
-    case 'pin_lesson': {
-      const { instance_id, topic } = args as { instance_id: string; topic: string };
-      const redis = await getConnection(instance_id);
-
-      // Verify the lesson exists
-      const lessonRaw = await redis.get(`cachly:lesson:best:${topic}`);
-      if (!lessonRaw) {
-        return `❌ No lesson found for topic \`${topic}\`.\n\nFirst create it with \`learn_from_attempts(topic="${topic}", ...)\`.`;
-      }
-
-      await redis.set(`cachly:lesson:pin:${topic}`, '1');
-      return [
-        `📌 **Pinned** \`${topic}\``,
-        '',
-        'This lesson will now appear at the top of every `session_start` briefing, regardless of age.',
-        '',
-        `Remove with: \`unpin_lesson(instance_id="...", topic="${topic}")\``,
-      ].join('\n');
-    }
-
-    // ── unpin_lesson ─────────────────────────────────────────────────────────
-    case 'unpin_lesson': {
-      const { instance_id, topic } = args as { instance_id: string; topic: string };
-      const redis = await getConnection(instance_id);
-      const deleted = await redis.del(`cachly:lesson:pin:${topic}`);
-      if (deleted === 0) {
-        return `ℹ️ \`${topic}\` was not pinned. Use \`brain_stats\` to see all pinned lessons.`;
-      }
-      return `📌 Unpinned \`${topic}\`. It will now follow normal recency/confidence decay in session_start.`;
-    }
-
     // ── v0.7 Knowledge Syndication: syndicate ────────────────────────────────
 
     default: