@winspan/claude-forge 8.41.0 → 8.50.6

package/tests/e2e/dashboard.spec.ts

@@ -0,0 +1,205 @@
+/**
+ * E2E 测试：管理后台 Dashboard
+ *
+ * 运行前提：
+ * 1. 安装 Playwright: npm install -D @playwright/test
+ * 2. 启动守护进程: claude-forge daemon start
+ * 3. 运行测试: npm run test:e2e
+ */
+
+import { test, expect } from '@playwright/test';
+
+const BASE_URL = 'http://localhost:3721';
+
+test.describe('Dashboard 页面', () => {
+  test('应该正确加载并显示统计卡片', async ({ page }) => {
+    await page.goto(BASE_URL);
+
+    // 等待页面加载
+    await page.waitForSelector('#dash-stats');
+
+    // 检查统计卡片是否存在
+    await expect(page.locator('.stat-card')).toHaveCount(4);
+
+    // 检查守护进程状态
+    const status = await page.locator('#daemon-status').textContent();
+    expect(['运行中', '离线', '检查中']).toContain(status);
+  });
+
+  test('应该显示近 7 天活动图表', async ({ page }) => {
+    await page.goto(BASE_URL);
+
+    // 检查图表容器
+    await expect(page.locator('#chart-activity')).toBeVisible();
+    await expect(page.locator('#chart-tools')).toBeVisible();
+  });
+
+  test('应该显示最近会话列表', async ({ page }) => {
+    await page.goto(BASE_URL);
+
+    // 检查会话列表容器
+    await expect(page.locator('#dash-sessions')).toBeVisible();
+  });
+});
+
+test.describe('Sessions 页面', () => {
+  test('应该正确加载会话列表', async ({ page }) => {
+    await page.goto(BASE_URL);
+
+    // 点击 Sessions 导航
+    await page.click('#nav-sessions');
+
+    // 等待页面切换
+    await page.waitForSelector('#page-sessions.active');
+
+    // 检查搜索框
+    await expect(page.locator('#sessions-search')).toBeVisible();
+
+    // 检查列表容器
+    await expect(page.locator('#sessions-list')).toBeVisible();
+  });
+
+  test('搜索功能应该正常工作', async ({ page }) => {
+    await page.goto(BASE_URL);
+    await page.click('#nav-sessions');
+    await page.waitForSelector('#page-sessions.active');
+
+    // 输入搜索关键词
+    await page.fill('#sessions-search', 'test');
+
+    // 等待搜索结果更新（通过 oninput 触发）
+    await page.waitForTimeout(300);
+
+    // 验证搜索框有值
+    const searchValue = await page.inputValue('#sessions-search');
+    expect(searchValue).toBe('test');
+  });
+
+  test('点击会话应该打开详情抽屉', async ({ page }) => {
+    await page.goto(BASE_URL);
+    await page.click('#nav-sessions');
+    await page.waitForSelector('#page-sessions.active');
+
+    // 等待会话列表加载
+    await page.waitForTimeout(500);
+
+    // 如果有会话，点击第一个
+    const firstSession = page.locator('.list-item').first();
+    if (await firstSession.isVisible()) {
+      await firstSession.click();
+
+      // 检查抽屉是否打开
+      await expect(page.locator('#drawer.open')).toBeVisible();
+      await expect(page.locator('#drawer-title')).toContainText('会话');
+    }
+  });
+});
+
+test.describe('Events 页面', () => {
+  test('应该正确加载事件列表', async ({ page }) => {
+    await page.goto(BASE_URL);
+    await page.click('#nav-events');
+    await page.waitForSelector('#page-events.active');
+
+    // 检查搜索框和筛选器
+    await expect(page.locator('#events-search')).toBeVisible();
+    await expect(page.locator('#events-type')).toBeVisible();
+
+    // 检查表格
+    await expect(page.locator('#events-body')).toBeVisible();
+  });
+
+  test('类型筛选应该正常工作', async ({ page }) => {
+    await page.goto(BASE_URL);
+    await page.click('#nav-events');
+    await page.waitForSelector('#page-events.active');
+
+    // 选择筛选类型
+    await page.selectOption('#events-type', 'PreToolUse');
+
+    // 等待筛选结果更新
+    await page.waitForTimeout(300);
+
+    // 验证筛选器有值
+    const selectedValue = await page.inputValue('#events-type');
+    expect(selectedValue).toBe('PreToolUse');
+  });
+});
+
+test.describe('Injections 页面', () => {
+  test('应该正确加载注入列表', async ({ page }) => {
+    await page.goto(BASE_URL);
+    await page.click('#nav-injections');
+    await page.waitForSelector('#page-injections.active');
+
+    // 检查搜索框和筛选器
+    await expect(page.locator('#inj-search')).toBeVisible();
+    await expect(page.locator('#inj-handler')).toBeVisible();
+
+    // 检查列表容器
+    await expect(page.locator('#inj-list')).toBeVisible();
+  });
+});
+
+test.describe('Rules 页面', () => {
+  test('应该正确加载规则列表', async ({ page }) => {
+    await page.goto(BASE_URL);
+    await page.click('#nav-rules');
+    await page.waitForSelector('#page-rules.active');
+
+    // 检查搜索框
+    await expect(page.locator('#rules-search')).toBeVisible();
+
+    // 检查列表容器
+    await expect(page.locator('#rules-list')).toBeVisible();
+  });
+});
+
+test.describe('Live 页面', () => {
+  test('应该正确加载实时监控页面', async ({ page }) => {
+    await page.goto(BASE_URL);
+    await page.click('#nav-live');
+    await page.waitForSelector('#page-live.active');
+
+    // 检查状态和按钮
+    await expect(page.locator('#live-status')).toBeVisible();
+    await expect(page.locator('#live-btn')).toBeVisible();
+
+    // 检查日志容器
+    await expect(page.locator('#live-log')).toBeVisible();
+  });
+});
+
+test.describe('导航功能', () => {
+  test('所有导航链接应该正常工作', async ({ page }) => {
+    await page.goto(BASE_URL);
+
+    const navItems = [
+      { id: 'nav-dashboard', pageId: 'page-dashboard' },
+      { id: 'nav-sessions', pageId: 'page-sessions' },
+      { id: 'nav-events', pageId: 'page-events' },
+      { id: 'nav-injections', pageId: 'page-injections' },
+      { id: 'nav-live', pageId: 'page-live' },
+      { id: 'nav-rules', pageId: 'page-rules' }
+    ];
+
+    for (const item of navItems) {
+      await page.click(`#${item.id}`);
+      await page.waitForSelector(`#${item.pageId}.active`);
+      await expect(page.locator(`#${item.pageId}`)).toHaveClass(/active/);
+    }
+  });
+
+  test('刷新按钮应该正常工作', async ({ page }) => {
+    await page.goto(BASE_URL);
+
+    // 点击刷新按钮
+    await page.click('button:has-text("刷新")');
+
+    // 等待页面重新加载
+    await page.waitForTimeout(500);
+
+    // 验证页面仍然可见
+    await expect(page.locator('#dash-stats')).toBeVisible();
+  });
+});

package/tests/e2e/routing-skill-e2e.test.ts

@@ -0,0 +1,39 @@
+/**
+ * E2E Test Suite: Routing & Skill Invocation Verification
+ *
+ * Tests the complete chain:
+ *   1. UserPrompt → Classifier → AgentRouter → routing_events
+ *   2. Agent execution → skill_invoke MCP call → skill_invocations
+ *   3. Data integrity: obeyed tracking, route_request_id linkage
+ *
+ * Prerequisites:
+ *   - Daemon must be running (claude-forge daemon start)
+ *   - Database at ~/.claude-forge/data.db
+ *   - MCP server mounted at http://127.0.0.1:3721/mcp
+ */
+
+import { describe, it, expect, beforeAll } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { FORGE_PATHS } from '../../src/core/constants.js';
+import { SQLiteStorage } from '../../src/core/storage/sqlite.js';
+
+const DAEMON_TOKEN_PATH = join(FORGE_PATHS.home(), 'daemon.token');
+const DB_PATH = FORGE_PATHS.database();
+
+describe('E2E: Routing & Skill Invocation', () => {
+  let storage: SQLiteStorage;
+  let daemonToken: string;
+
+  beforeAll(() => {
+    // Read daemon token for MCP auth
+    try {
+      daemonToken = readFileSync(DAEMON_TOKEN_PATH, 'utf-8').trim();
+    } catch (err) {
+      throw new Error(
+        `Cannot read daemon token at ${DAEMON_TOKEN_PATH}. ` +
+        `Is the daemon running? Run: claude-forge daemon start`
+      );
+    }
+
+    // Connect to live database

package/tests/helpers/mock-ai.ts

@@ -0,0 +1,92 @@
+import type { AIProvider } from '../../src/core/ai/provider.js';
+
+/**
+ * Mock AI Provider for testing
+ */
+export class MockAIProvider implements AIProvider {
+  private responses: string[] = [];
+  private currentIndex = 0;
+  public callHistory: Array<{ prompt: string; options?: Record<string, unknown> }> = [];
+
+  constructor(responses: string[] = ['mock response']) {
+    this.responses = responses;
+  }
+
+  async complete(prompt: string, options?: { maxTokens?: number; temperature?: number }): Promise<string> {
+    this.callHistory.push({ prompt, options });
+
+    if (this.currentIndex >= this.responses.length) {
+      return this.responses[this.responses.length - 1] || 'default mock response';
+    }
+
+    const response = this.responses[this.currentIndex];
+    this.currentIndex++;
+    return response;
+  }
+
+  /**
+   * Add more responses to the queue
+   */
+  addResponse(response: string): void {
+    this.responses.push(response);
+  }
+
+  /**
+   * Reset the provider state
+   */
+  reset(): void {
+    this.currentIndex = 0;
+    this.callHistory = [];
+  }
+
+  /**
+   * Get the number of times complete() was called
+   */
+  getCallCount(): number {
+    return this.callHistory.length;
+  }
+
+  /**
+   * Get the last prompt sent to complete()
+   */
+  getLastPrompt(): string | undefined {
+    return this.callHistory[this.callHistory.length - 1]?.prompt;
+  }
+}
+
+/**
+ * Create a mock AI provider that always returns the same response
+ */
+export function createMockAI(response: string = 'mock response'): MockAIProvider {
+  return new MockAIProvider([response]);
+}
+
+/**
+ * Create a mock AI provider with multiple responses (returns them in sequence)
+ */
+export function createMockAIWithResponses(responses: string[]): MockAIProvider {
+  return new MockAIProvider(responses);
+}
+
+/**
+ * Create a mock AI provider that throws an error
+ */
+export function createFailingMockAI(errorMessage: string = 'Mock AI error'): AIProvider {
+  return {
+    async complete(): Promise<string> {
+      throw new Error(errorMessage);
+    },
+  };
+}
+
+/**
+ * Create a mock AI provider that simulates slow responses
+ */
+export function createSlowMockAI(response: string = 'slow response', delayMs: number = 100): AIProvider {
+  return {
+    async complete(): Promise<string> {
+      await new Promise(resolve => setTimeout(resolve, delayMs));
+      return response;
+    },
+  };
+}

package/tests/helpers/mock-storage.ts

@@ -0,0 +1,159 @@
+import Database from 'better-sqlite3';
+import type { ForgeEvent } from '../../src/core/types.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import { tmpdir } from 'node:os';
+
+/**
+ * Create a temporary in-memory SQLite database for testing
+ */
+export function createMockDatabase(): Database.Database {
+  const db = new Database(':memory:');
+
+  // Create minimal schema
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS events (
+      event_id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      project_path TEXT NOT NULL,
+      timestamp TEXT NOT NULL,
+      hook_type TEXT NOT NULL,
+      tool_name TEXT,
+      tool_input TEXT,
+      tool_output TEXT,
+      user_prompt TEXT,
+      ai_response TEXT,
+      distilled INTEGER DEFAULT 0,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS sessions (
+      session_id TEXT PRIMARY KEY,
+      project_path TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'active',
+      first_prompt TEXT,
+      start_time TEXT NOT NULL,
+      end_time TEXT,
+      last_event_time TEXT,
+      event_count INTEGER DEFAULT 0,
+      created_at TEXT DEFAULT (datetime('now')),
+      updated_at TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS routing_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      route_request_id TEXT,
+      project_path TEXT NOT NULL,
+      ts INTEGER NOT NULL,
+      prompt TEXT NOT NULL,
+      intent_json TEXT NOT NULL,
+      routed_to_type TEXT,
+      routed_to_name TEXT,
+      is_forced INTEGER DEFAULT 0,
+      obeyed INTEGER,
+      classification_ms INTEGER
+    );
+
+    CREATE TABLE IF NOT EXISTS injections (
+      id TEXT PRIMARY KEY,
+      event_id TEXT,
+      session_id TEXT NOT NULL,
+      timestamp TEXT NOT NULL,
+      source_handler TEXT NOT NULL,
+      injection_type TEXT NOT NULL,
+      content TEXT NOT NULL,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE INDEX idx_events_session ON events(session_id);
+    CREATE INDEX idx_events_timestamp ON events(timestamp DESC);
+    CREATE INDEX idx_sessions_project ON sessions(project_path);
+    CREATE INDEX idx_routing_events_session ON routing_events(session_id);
+    CREATE INDEX idx_injections_session ON injections(session_id);
+  `);
+
+  return db;
+}
+
+/**
+ * Create a temporary file-based database for testing
+ */
+export function createTempDatabase(): { db: Database.Database; path: string; cleanup: () => void } {
+  const dbPath = path.join(tmpdir(), `test-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
+  const db = createMockDatabase();
+
+  const cleanup = () => {
+    try {
+      db.close();
+      if (fs.existsSync(dbPath)) {
+        fs.unlinkSync(dbPath);
+      }
+    } catch (err) {
+      // Ignore cleanup errors
+    }
+  };
+
+  return { db, path: dbPath, cleanup };
+}
+
+/**
+ * Create mock ForgeEvent for testing
+ */
+export function createMockEvent(overrides?: Partial<ForgeEvent>): ForgeEvent {
+  return {
+    event_id: `event-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    session_id: 'test-session',
+    project_path: '/test/project',
+    timestamp: new Date().toISOString(),
+    hook_type: 'UserPromptSubmit',
+    user_prompt: 'test prompt',
+    ...overrides,
+  };
+}
+
+/**
+ * Insert mock events into database
+ */
+export function insertMockEvents(db: Database.Database, events: ForgeEvent[]): void {
+  const stmt = db.prepare(`
+    INSERT INTO events (event_id, session_id, project_path, timestamp, hook_type,
+                        tool_name, tool_input, tool_output, user_prompt, ai_response, distilled)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0)
+  `);
+
+  for (const event of events) {
+    stmt.run(
+      event.event_id || `event-${Date.now()}`,
+      event.session_id,
+      event.project_path,
+      event.timestamp,
+      event.hook_type,
+      event.tool_name ?? null,
+      event.tool_input ? JSON.stringify(event.tool_input) : null,
+      event.tool_output ? JSON.stringify(event.tool_output) : null,
+      event.user_prompt ?? null,
+      event.ai_response ?? null,
+    );
+  }
+}
+
+/**
+ * Query all events from database
+ */
+export function queryAllEvents(db: Database.Database): ForgeEvent[] {
+  const rows = db.prepare('SELECT * FROM events ORDER BY timestamp DESC').all() as Array<Record<string, unknown>>;
+
+  return rows.map(row => ({
+    event_id: row.event_id as string,
+    session_id: row.session_id as string,
+    project_path: row.project_path as string,
+    timestamp: row.timestamp as string,
+    hook_type: row.hook_type as ForgeEvent['hook_type'],
+    tool_name: (row.tool_name as string) || undefined,
+    tool_input: row.tool_input ? JSON.parse(row.tool_input as string) : undefined,
+    tool_output: row.tool_output ? JSON.parse(row.tool_output as string) : undefined,
+    user_prompt: (row.user_prompt as string) || undefined,
+    ai_response: (row.ai_response as string) || undefined,
+  }));
+}

package/tests/integration/queue-replay.integration.test.ts

@@ -0,0 +1,193 @@
+/**
+ * Integration test: hook failure queue → daemon startup replay
+ *
+ * Uses real SQLiteStorage (no mocks for storage layer).
+ * Does NOT start an actual daemon process — instead tests the queue
+ * module functions directly with the same storage that daemon would use.
+ *
+ * Test scenarios:
+ * 1. Enqueue 3 events → replayQueue → all 3 in DB, queue empty
+ * 2. Second replayQueue → skipped=3 (dedup), DB still has 3 rows
+ * 3. TTL and bad JSON → dead-lettered correctly
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mkdirSync, mkdtempSync, readdirSync, rmSync, writeFileSync, utimesSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+
+describe('Queue → Daemon Replay Integration', () => {
+  let tempHome: string;
+  let queueDir: string;
+  let deadDir: string;
+  let dbPath: string;
+  let originalHome: string | undefined;
+
+  beforeEach(async () => {
+    originalHome = process.env['HOME'];
+    tempHome = mkdtempSync(join(tmpdir(), 'forge-integ-'));
+    process.env['HOME'] = tempHome;
+
+    queueDir = join(tempHome, '.claude-forge', 'queue');
+    deadDir = join(queueDir, 'dead');
+    dbPath = join(tempHome, 'data.db');
+
+    mkdirSync(queueDir, { recursive: true });
+    mkdirSync(deadDir, { recursive: true });
+
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    process.env['HOME'] = originalHome;
+    rmSync(tempHome, { recursive: true, force: true });
+    vi.resetModules();
+  });
+
+  it('enqueues 3 events then replays all into DB and empties queue', async () => {
+    const { enqueueEvent, replayQueue } = await import('../../src/core/queue/index.js');
+    const { SQLiteStorage } = await import('../../src/core/storage/sqlite.js');
+    const storage = new SQLiteStorage(dbPath);
+
+    const events = [
+      {
+        session_id: 'integ-session-1',
+        project_path: '/tmp/proj',
+        timestamp: new Date().toISOString(),
+        hook_type: 'UserPromptSubmit' as const,
+        user_prompt: 'prompt 1',
+        event_id: randomUUID(),
+      },
+      {
+        session_id: 'integ-session-1',
+        project_path: '/tmp/proj',
+        timestamp: new Date().toISOString(),
+        hook_type: 'PreToolUse' as const,
+        tool_name: 'Bash',
+        event_id: randomUUID(),
+      },
+      {
+        session_id: 'integ-session-1',
+        project_path: '/tmp/proj',
+        timestamp: new Date().toISOString(),
+        hook_type: 'PostToolUse' as const,
+        tool_name: 'Bash',
+        tool_input: { command: 'ls' },
+        tool_output: { output: 'file.txt' },
+        event_id: randomUUID(),
+      },
+    ];
+
+    // Simulate daemon downtime: enqueue all events
+    for (const event of events) {
+      enqueueEvent(event);
+    }
+
+    const queuedFiles = readdirSync(queueDir).filter((f) => f.endsWith('.json'));
+    expect(queuedFiles).toHaveLength(3);
+
+    // Simulate daemon startup: replay queue
+    const result = await replayQueue(storage);
+    expect(result.replayed).toBe(3);
+    expect(result.skipped).toBe(0);
+    expect(result.dead).toBe(0);
+
+    // Verify all events are in DB
+    const dbEvents = storage.queryEvents({ session_id: 'integ-session-1' });
+    expect(dbEvents).toHaveLength(3);
+
+    // Verify queue is empty
+    const remainingFiles = readdirSync(queueDir).filter((f) => f.endsWith('.json'));
+    expect(remainingFiles).toHaveLength(0);
+
+    storage.close();
+  });
+
+  it('second replayQueue skips all events (dedup), DB still has 3 rows', async () => {
+    const { enqueueEvent, replayQueue } = await import('../../src/core/queue/index.js');
+    const { SQLiteStorage } = await import('../../src/core/storage/sqlite.js');
+    const storage = new SQLiteStorage(dbPath);
+
+    const eventIds = [randomUUID(), randomUUID(), randomUUID()];
+    const events = eventIds.map((id, i) => ({
+      session_id: 'dedup-session',
+      project_path: '/tmp',
+      timestamp: new Date().toISOString(),
+      hook_type: 'Notification' as const,
+      event_id: id,
+      user_prompt: `prompt ${i}`,
+    }));
+
+    // First pass: enqueue + replay (all 3 enter DB)
+    for (const event of events) {
+      enqueueEvent(event);
+    }
+    const first = await replayQueue(storage);
+    expect(first.replayed).toBe(3);
+
+    // Queue is empty now. Re-enqueue the same events to simulate a second replay
+    for (const event of events) {
+      enqueueEvent(event);
+    }
+
+    // Second pass: all 3 should be skipped as duplicates
+    const second = await replayQueue(storage);
+    expect(second.skipped).toBe(3);
+    expect(second.replayed).toBe(0);
+
+    // DB still has exactly 3 events
+    const dbEvents = storage.queryEvents({ session_id: 'dedup-session' });
+    expect(dbEvents).toHaveLength(3);
+
+    storage.close();
+  });
+
+  it('dead-letters TTL-expired and corrupt files, replays valid ones', async () => {
+    const { enqueueEvent, replayQueue, TTL_DAYS } = await import('../../src/core/queue/index.js');
+    const { SQLiteStorage } = await import('../../src/core/storage/sqlite.js');
+    const storage = new SQLiteStorage(dbPath);
+
+    // Valid event
+    const validEvent = {
+      session_id: 'mixed-session',
+      project_path: '/tmp',
+      timestamp: new Date().toISOString(),
+      hook_type: 'UserPromptSubmit' as const,
+      user_prompt: 'valid',
+      event_id: randomUUID(),
+    };
+    enqueueEvent(validEvent);
+
+    // Corrupt JSON file
+    writeFileSync(join(queueDir, '2020-02-01T00-00-00-000Z-corrupt.json'), '{bad json]]');
+
+    // TTL-expired file (valid JSON but old mtime)
+    const oldEventPath = join(queueDir, '2000-01-01T00-00-00-000Z-expired.json');
+    writeFileSync(oldEventPath, JSON.stringify({
+      session_id: 'mixed-session',
+      project_path: '/tmp',
+      timestamp: '2000-01-01T00:00:00.000Z',
+      hook_type: 'Notification' as const,
+      event_id: randomUUID(),
+    }));
+    const pastTime = new Date(Date.now() - (TTL_DAYS + 2) * 24 * 60 * 60 * 1000);
+    utimesSync(oldEventPath, pastTime, pastTime);
+
+    const result = await replayQueue(storage);
+
+    expect(result.replayed).toBe(1);
+    expect(result.dead).toBe(2); // corrupt + expired
+    expect(result.skipped).toBe(0);
+
+    // dead-letter dir should have 2 files
+    const deadFiles = readdirSync(deadDir).filter((f) => f.endsWith('.json'));
+    expect(deadFiles).toHaveLength(2);
+
+    // queue is empty
+    const queueFiles = readdirSync(queueDir).filter((f) => f.endsWith('.json'));
+    expect(queueFiles).toHaveLength(0);
+
+    storage.close();
+  });
+});