@intutic/mcp-governance-proxy 1.5.0 → 1.6.1

package/src/__tests__/interceptor.test.ts

@@ -1,229 +0,0 @@
-/**
- * interceptor.test.ts — Unit tests for the MCP governance proxy interceptor.
- *
- * Zero vi.mock — tests the actual decision engine with in-process policy stubs.
- *
- * @module
- */
-
-import { describe, it, expect, beforeEach } from 'vitest'
-import { ToolCallInterceptor } from '../interceptor.js'
-import { PolicyClient } from '../policy.js'
-import type { SopRule } from '../policy.js'
-import { GovernanceEmitter } from '../emitter.js'
-import * as node_path from 'node:path'
-import * as node_os from 'node:os'
-
-// ─── Minimal in-process stub clients ─────────────────────────────────────────
-
-class StubPolicyClient extends PolicyClient {
-  private _rules: SopRule[] = []
-
-  constructor(rules: SopRule[] = []) {
-    // Pass dummy values — we override getRules() and matchRule()
-    super('http://localhost:0', '', 'test-ws', 60_000)
-    this._rules = rules
-  }
-
-  override getRules(): readonly SopRule[] {
-    return this._rules
-  }
-
-  override matchRule(toolName: string, toolInputJson: string): SopRule | null {
-    for (const rule of this._rules) {
-      try {
-        if (!new RegExp(rule.toolPattern).test(toolName)) continue
-        if (rule.argPattern && !new RegExp(rule.argPattern).test(toolInputJson)) continue
-        return rule
-      } catch {
-        continue
-      }
-    }
-    return null
-  }
-
-  override start(): void { /* no-op */ }
-  override stop(): void { /* no-op */ }
-  override async refresh(): Promise<void> { /* no-op */ }
-}
-
-class StubEmitter extends GovernanceEmitter {
-  readonly emitted: Array<{ kind: string; toolName: string; toolInput: unknown; reason?: string }> = []
-
-  constructor() {
-    super('http://localhost:0', '', node_path.join(node_os.homedir(), '.intutic-test', 'events.jsonl'), 'test-ws')
-  }
-
-  override emit(kind: 'tool_allowed' | 'tool_blocked' | 'tool_redacted', toolName: string, toolInput: unknown, reason?: string): void {
-    this.emitted.push({ kind, toolName, toolInput, reason })
-  }
-}
-
-// ─── Tests ────────────────────────────────────────────────────────────────────
-
-describe('ToolCallInterceptor', () => {
-  let emitter: StubEmitter
-
-  beforeEach(() => {
-    emitter = new StubEmitter()
-  })
-
-  describe('DLP scanning', () => {
-    it('blocks tool calls containing OpenAI API keys', async () => {
-      const policy = new StubPolicyClient()
-      const interceptor = new ToolCallInterceptor(policy, emitter, true)
-
-      const decision = await interceptor.decide('Bash', { command: 'echo sk-abc123def456ghi789jkl012mno345pqr' })
-      expect(decision.action).toBe('block')
-      expect(emitter.emitted).toHaveLength(1)
-      expect(emitter.emitted[0]?.kind).toBe('tool_blocked')
-    })
-
-    it('blocks tool calls containing Anthropic API keys', async () => {
-      const policy = new StubPolicyClient()
-      const interceptor = new ToolCallInterceptor(policy, emitter, true)
-
-      const decision = await interceptor.decide('Write', { content: 'key=sk-ant-api03-verylongantkeyhere12345678901234' })
-      expect(decision.action).toBe('block')
-    })
-
-    it('blocks rm -rf / commands', async () => {
-      const policy = new StubPolicyClient()
-      const interceptor = new ToolCallInterceptor(policy, emitter, true)
-
-      const decision = await interceptor.decide('Bash', { command: 'rm -rf /' })
-      expect(decision.action).toBe('block')
-      expect((decision as { action: 'block'; reason: string }).reason).toContain('Destructive')
-    })
-
-    it('blocks SQL DROP TABLE', async () => {
-      const policy = new StubPolicyClient()
-      const interceptor = new ToolCallInterceptor(policy, emitter, true)
-
-      const decision = await interceptor.decide('mcp__database__execute', { query: 'DROP TABLE users' })
-      expect(decision.action).toBe('block')
-    })
-
-    it('allows benign tool calls with no DLP match', async () => {
-      const policy = new StubPolicyClient()
-      const interceptor = new ToolCallInterceptor(policy, emitter, true)
-
-      const decision = await interceptor.decide('Read', { path: '/tmp/hello.txt' })
-      expect(decision.action).toBe('allow')
-      expect(emitter.emitted[0]?.kind).toBe('tool_allowed')
-    })
-  })
-
-  describe('SOP policy rules', () => {
-    it('blocks tool when matching block rule exists', async () => {
-      const rules: SopRule[] = [{
-        id: 'rule-1',
-        toolPattern: 'Bash',
-        action: 'block',
-        reason: 'Bash execution not permitted in this workspace',
-      }]
-      const policy = new StubPolicyClient(rules)
-      const interceptor = new ToolCallInterceptor(policy, emitter, true)
-
-      const decision = await interceptor.decide('Bash', { command: 'ls -la' })
-      expect(decision.action).toBe('block')
-      expect((decision as { action: 'block'; reason: string }).reason).toContain('Bash execution')
-    })
-
-    it('allows tool when pattern does not match', async () => {
-      const rules: SopRule[] = [{
-        id: 'rule-1',
-        toolPattern: 'Bash',
-        action: 'block',
-        reason: 'Bash blocked',
-      }]
-      const policy = new StubPolicyClient(rules)
-      const interceptor = new ToolCallInterceptor(policy, emitter, true)
-
-      const decision = await interceptor.decide('Read', { path: '/tmp/safe.txt' })
-      expect(decision.action).toBe('allow')
-    })
-
-    it('blocks when arg pattern also matches', async () => {
-      const rules: SopRule[] = [{
-        id: 'rule-2',
-        toolPattern: 'mcp__.*',
-        argPattern: 'prod.*database',
-        action: 'block',
-        reason: 'Production database access blocked',
-      }]
-      const policy = new StubPolicyClient(rules)
-      const interceptor = new ToolCallInterceptor(policy, emitter, true)
-
-      const decision = await interceptor.decide('mcp__postgres__query', { dsn: 'prod-us-east-1-database' })
-      expect(decision.action).toBe('block')
-    })
-
-    it('allows when arg pattern does NOT match', async () => {
-      const rules: SopRule[] = [{
-        id: 'rule-2',
-        toolPattern: 'mcp__.*',
-        argPattern: 'prod.*database',
-        action: 'block',
-        reason: 'Production database access blocked',
-      }]
-      const policy = new StubPolicyClient(rules)
-      const interceptor = new ToolCallInterceptor(policy, emitter, true)
-
-      const decision = await interceptor.decide('mcp__postgres__query', { dsn: 'dev-local-db' })
-      expect(decision.action).toBe('allow')
-    })
-
-    it('treats require_approval as block (headless proxy)', async () => {
-      const rules: SopRule[] = [{
-        id: 'rule-3',
-        toolPattern: 'Write',
-        action: 'require_approval',
-        reason: 'File writes require review',
-      }]
-      const policy = new StubPolicyClient(rules)
-      const interceptor = new ToolCallInterceptor(policy, emitter, true)
-
-      const decision = await interceptor.decide('Write', { path: '/etc/passwd', content: 'test' })
-      expect(decision.action).toBe('block')
-      expect((decision as { action: 'block'; reason: string }).reason).toContain('human approval')
-    })
-  })
-
-  describe('fail-open behavior', () => {
-    it('allows when policy client throws (failOpen=true)', async () => {
-      const policy = new StubPolicyClient()
-      // Override matchRule to throw — simulates policy engine failure
-      policy.matchRule = () => { throw new Error('Policy engine down') }
-
-      const interceptor = new ToolCallInterceptor(policy, emitter, true)
-      const decision = await interceptor.decide('Read', { path: '/tmp/ok.txt' })
-      expect(decision.action).toBe('allow')
-    })
-  })
-
-  describe('fail-closed behavior', () => {
-    it('blocks when policy client throws (failOpen=false)', async () => {
-      const policy = new StubPolicyClient()
-      policy.matchRule = () => { throw new Error('Policy engine down') }
-
-      const interceptor = new ToolCallInterceptor(policy, emitter, false)
-      const decision = await interceptor.decide('Read', { path: '/tmp/ok.txt' })
-      expect(decision.action).toBe('block')
-      expect((decision as { action: 'block'; reason: string }).reason).toContain('control plane unreachable')
-    })
-
-    it('blocks when DLP scan throws (failOpen=false)', async () => {
-      const policy = new StubPolicyClient()
-      const interceptor = new ToolCallInterceptor(policy, emitter, false)
-
-      // Circular references cause JSON.stringify / scanning to throw or error
-      const circular: any = {}
-      circular.self = circular
-
-      const decision = await interceptor.decide('Read', circular)
-      expect(decision.action).toBe('block')
-      expect((decision as { action: 'block'; reason: string }).reason).toContain('control plane unreachable')
-    })
-  })
-})

package/src/__tests__/unit/policyCache.test.ts

@@ -1,95 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest'
-import * as http from 'node:http'
-import * as net from 'node:net'
-
-describe('policyCache Unit Tests', () => {
-  let mockServer: http.Server
-  let port: number
-  let requestCount = 0
-  let latestWorkspaceId: string | null = null
-
-  let resolvePolicy: any
-  let invalidatePolicy: any
-  let getCacheStats: any
-
-  beforeAll(async () => {
-    mockServer = http.createServer((req, res) => {
-      requestCount++
-      const url = new URL(req.url ?? '', `http://${req.headers.host}`)
-      latestWorkspaceId = url.searchParams.get('workspaceId')
-
-      res.writeHead(200, { 'Content-Type': 'application/json' })
-      res.end(
-        JSON.stringify({
-          workspaceId: latestWorkspaceId,
-          sopRules: [
-            {
-              id: 'rule_1',
-              toolPattern: 'Bash',
-              action: 'block',
-              reason: 'No destructive commands allowed',
-            },
-          ],
-          dlpPatterns: [],
-          interventionMode: 'BLOCK',
-        })
-      )
-    })
-
-    await new Promise<void>((resolve) => {
-      mockServer.listen(0, '127.0.0.1', () => {
-        const addr = mockServer.address() as net.AddressInfo | null
-        port = addr?.port ?? 3001
-        process.env['CONTROL_PLANE_URL'] = `http://127.0.0.1:${port}`
-        resolve()
-      })
-    })
-
-    // Import after process.env is set to ensure it uses the mock URL
-    const mod = await import('../../daemon/policyCache.js')
-    resolvePolicy = mod.resolvePolicy
-    invalidatePolicy = mod.invalidatePolicy
-    getCacheStats = mod.getCacheStats
-
-    // Clean up any stale cache from prior runs in Valkey
-    invalidatePolicy('ws_test_cache_miss')
-    requestCount = 0
-    latestWorkspaceId = null
-  })
-
-  afterAll(async () => {
-    await new Promise<void>((resolve) => mockServer.close(() => resolve()))
-  })
-
-  it('fetches policy from control plane on cache miss', async () => {
-    const wsId = 'ws_test_cache_miss'
-    const policy = await resolvePolicy(wsId)
-    expect(policy).not.toBeNull()
-    expect(policy!.workspaceId).toBe(wsId)
-    expect(policy!.sopRules).toHaveLength(1)
-    expect(policy!.sopRules[0]!.id).toBe('rule_1')
-    expect(requestCount).toBe(1)
-    expect(latestWorkspaceId).toBe(wsId)
-  })
-
-  it('serves policy from memory on cache hit', async () => {
-    const wsId = 'ws_test_cache_miss' // reuse the same wsId
-    const policy = await resolvePolicy(wsId)
-    expect(policy).not.toBeNull()
-    expect(requestCount).toBe(1) // Request count remains 1 due to cache hit
-  })
-
-  it('invalidates policy correctly', async () => {
-    const wsId = 'ws_test_cache_miss'
-    invalidatePolicy(wsId)
-
-    const policy = await resolvePolicy(wsId)
-    expect(policy).not.toBeNull()
-    expect(requestCount).toBe(2) // Request count increments to 2 on new fetch
-  })
-
-  it('tracks cache entries stats correctly', () => {
-    const stats = getCacheStats()
-    expect(stats.entries).toBeGreaterThanOrEqual(1)
-  })
-})

package/src/__tests__/unit/socketServer.test.ts

@@ -1,220 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest'
-import * as net from 'node:net'
-import * as path from 'node:path'
-import * as os from 'node:os'
-import * as fs from 'node:fs/promises'
-import { createSocketServer } from '../../daemon/socketServer.js'
-
-describe('socketServer Unit Tests', () => {
-  const socketPath = path.join(os.tmpdir(), `mcp-proxy-test-${Date.now()}.sock`)
-  let server: net.Server
-
-  beforeAll(async () => {
-    process.env['MCP_DAEMON_SOCKET'] = socketPath
-    await fs.rm(socketPath, { force: true })
-    server = createSocketServer()
-    await new Promise<void>((resolve) => server.listen(socketPath, () => resolve()))
-  })
-
-  afterAll(async () => {
-    await new Promise<void>((resolve) => server.close(() => resolve()))
-    await fs.rm(socketPath, { force: true })
-  })
-
-  it('binds to unix socket and responds to proxy.health_check JSON-RPC', async () => {
-    const response = await new Promise<any>((resolve, reject) => {
-      const client = net.createConnection(socketPath)
-      client.setEncoding('utf8')
-
-      let buffer = ''
-      const req = {
-        jsonrpc: '2.0',
-        id: 'req_123',
-        method: 'proxy.health_check',
-        params: {},
-      }
-
-      client.on('connect', () => {
-        client.write(JSON.stringify(req) + '\n')
-      })
-
-      client.on('data', (chunk) => {
-        buffer += chunk
-        if (buffer.includes('\n')) {
-          try {
-            resolve(JSON.parse(buffer.trim()))
-          } catch (err) {
-            reject(err)
-          } finally {
-            client.end()
-          }
-        }
-      })
-
-      client.on('error', reject)
-    })
-
-    expect(response.jsonrpc).toBe('2.0')
-    expect(response.id).toBe('req_123')
-    expect(response.result).toBeDefined()
-    expect(response.result.status).toBe('ok')
-  })
-
-  it('responds to policy.get JSON-RPC', async () => {
-    const response = await new Promise<any>((resolve, reject) => {
-      const client = net.createConnection(socketPath)
-      client.setEncoding('utf8')
-
-      let buffer = ''
-      const req = {
-        jsonrpc: '2.0',
-        id: 'req_policy_get',
-        method: 'policy.get',
-        params: { workspaceId: 'ws_test' },
-      }
-
-      client.on('connect', () => {
-        client.write(JSON.stringify(req) + '\n')
-      })
-
-      client.on('data', (chunk) => {
-        buffer += chunk
-        if (buffer.includes('\n')) {
-          try {
-            resolve(JSON.parse(buffer.trim()))
-          } catch (err) {
-            reject(err)
-          } finally {
-            client.end()
-          }
-        }
-      })
-
-      client.on('error', reject)
-    })
-
-    expect(response.jsonrpc).toBe('2.0')
-    expect(response.id).toBe('req_policy_get')
-    expect(response.result).toBeDefined()
-  })
-
-  it('responds to policy.invalidate JSON-RPC', async () => {
-    const response = await new Promise<any>((resolve, reject) => {
-      const client = net.createConnection(socketPath)
-      client.setEncoding('utf8')
-
-      let buffer = ''
-      const req = {
-        jsonrpc: '2.0',
-        id: 'req_policy_invalidate',
-        method: 'policy.invalidate',
-        params: { workspaceId: 'ws_test' },
-      }
-
-      client.on('connect', () => {
-        client.write(JSON.stringify(req) + '\n')
-      })
-
-      client.on('data', (chunk) => {
-        buffer += chunk
-        if (buffer.includes('\n')) {
-          try {
-            resolve(JSON.parse(buffer.trim()))
-          } catch (err) {
-            reject(err)
-          } finally {
-            client.end()
-          }
-        }
-      })
-
-      client.on('error', reject)
-    })
-
-    expect(response.jsonrpc).toBe('2.0')
-    expect(response.id).toBe('req_policy_invalidate')
-    expect(response.result.invalidated).toBe(true)
-  })
-
-  it('responds to telemetry.enqueue JSON-RPC', async () => {
-    const response = await new Promise<any>((resolve, reject) => {
-      const client = net.createConnection(socketPath)
-      client.setEncoding('utf8')
-
-      let buffer = ''
-      const req = {
-        jsonrpc: '2.0',
-        id: 'req_telemetry_enqueue',
-        method: 'telemetry.enqueue',
-        params: {
-          event: 'tool_allowed',
-          toolName: 'read_file',
-          workspaceId: 'ws_test',
-          harnessType: 'mcp-governance-proxy',
-          timestamp: new Date().toISOString()
-        },
-      }
-
-      client.on('connect', () => {
-        client.write(JSON.stringify(req) + '\n')
-      })
-
-      client.on('data', (chunk) => {
-        buffer += chunk
-        if (buffer.includes('\n')) {
-          try {
-            resolve(JSON.parse(buffer.trim()))
-          } catch (err) {
-            reject(err)
-          } finally {
-            client.end()
-          }
-        }
-      })
-
-      client.on('error', reject)
-    })
-
-    expect(response.jsonrpc).toBe('2.0')
-    expect(response.id).toBe('req_telemetry_enqueue')
-    expect(response.result.queued).toBe(true)
-  })
-
-  it('responds to proxy.tool_call JSON-RPC', async () => {
-    const response = await new Promise<any>((resolve, reject) => {
-      const client = net.createConnection(socketPath)
-      client.setEncoding('utf8')
-
-      let buffer = ''
-      const req = {
-        jsonrpc: '2.0',
-        id: 'req_tool_call',
-        method: 'proxy.tool_call',
-        params: { workspaceId: 'ws_test' },
-      }
-
-      client.on('connect', () => {
-        client.write(JSON.stringify(req) + '\n')
-      })
-
-      client.on('data', (chunk) => {
-        buffer += chunk
-        if (buffer.includes('\n')) {
-          try {
-            resolve(JSON.parse(buffer.trim()))
-          } catch (err) {
-            reject(err)
-          } finally {
-            client.end()
-          }
-        }
-      })
-
-      client.on('error', reject)
-    })
-
-    expect(response.jsonrpc).toBe('2.0')
-    expect(response.id).toBe('req_tool_call')
-    expect(response.result.allowed).toBeDefined()
-  })
-})

package/src/__tests__/unit/telemetryBatcher.test.ts

@@ -1,78 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest'
-import * as http from 'node:http'
-import * as net from 'node:net'
-import * as os from 'node:os'
-import * as path from 'node:path'
-import * as fs from 'node:fs/promises'
-
-describe('telemetryBatcher Unit Tests', () => {
-  let mockServer: http.Server
-  let port: number
-  let receivedPayloads: any[] = []
-
-  let enqueueEvent: any
-  let startBatcher: any
-  let stopBatcher: any
-
-  beforeAll(async () => {
-    // Clear stale disk buffer file to ensure hermetic tests
-    const bufPath = path.join(os.homedir(), '.intutic', 'telemetry-buffer.ndjson')
-    await fs.rm(bufPath, { force: true })
-
-    mockServer = http.createServer((req, res) => {
-      let body = ''
-      req.on('data', (c) => {
-        body += c.toString()
-      })
-      req.on('end', () => {
-        try {
-          receivedPayloads.push(JSON.parse(body))
-        } catch {}
-        res.writeHead(200, { 'Content-Type': 'application/json' })
-        res.end(JSON.stringify({ ok: true }))
-      })
-    })
-
-    await new Promise<void>((resolve) => {
-      mockServer.listen(0, '127.0.0.1', () => {
-        const addr = mockServer.address() as net.AddressInfo | null
-        port = addr?.port ?? 3001
-        process.env['CONTROL_PLANE_URL'] = `http://127.0.0.1:${port}`
-        process.env['MCP_DAEMON_TELEMETRY_FLUSH_MS'] = '100' // Flush fast for test
-        resolve()
-      })
-    })
-
-    // Import after process.env is set to ensure it uses the mock URL
-    const mod = await import('../../daemon/telemetryBatcher.js')
-    enqueueEvent = mod.enqueueEvent
-    startBatcher = mod.startBatcher
-    stopBatcher = mod.stopBatcher
-  })
-
-  afterAll(async () => {
-    await stopBatcher()
-    await new Promise<void>((resolve) => mockServer.close(() => resolve()))
-  })
-
-  it('batches and uploads enqueued telemetry events', async () => {
-    startBatcher()
-
-    const event = {
-      event: 'tool_blocked',
-      toolName: 'Bash',
-      workspaceId: 'ws_test_telemetry',
-      harnessType: 'mcp-governance-proxy',
-      timestamp: new Date().toISOString(),
-    }
-
-    enqueueEvent(event)
-
-    // Wait for the 100ms flush timer to trigger
-    await new Promise((resolve) => setTimeout(resolve, 250))
-
-    expect(receivedPayloads).toHaveLength(1)
-    expect(receivedPayloads[0].events).toHaveLength(1)
-    expect(receivedPayloads[0].events[0].toolName).toBe('Bash')
-  })
-})