@intutic/mcp-governance-proxy 1.0.3

package/src/__tests__/integration/daemon-shim.test.ts

@@ -0,0 +1,125 @@
+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 * as http from 'node:http'
+import { createSocketServer } from '../../daemon/socketServer.js'
+import { callDaemonSocket } from '../../daemonClient.js'
+import { PolicyClient } from '../../policy.js'
+import { GovernanceEmitter } from '../../emitter.js'
+
+describe('Daemon-Shim Integration Tests', () => {
+  const socketPath = path.join(os.tmpdir(), `mcp-daemon-shim-test-${Date.now()}.sock`)
+  let server: net.Server
+  let mockCp: http.Server
+  let cpPort: number
+  let lastWorkspaceId: string | null = null
+  let telemetryEvents: any[] = []
+
+  beforeAll(async () => {
+    process.env['MCP_DAEMON_SOCKET'] = socketPath
+    await fs.rm(socketPath, { force: true })
+
+    // Setup mock control plane HTTP server
+    mockCp = http.createServer((req, res) => {
+      const url = new URL(req.url ?? '', `http://${req.headers.host}`)
+      if (url.pathname === '/api/v1/policy/resolve') {
+        lastWorkspaceId = url.searchParams.get('workspaceId')
+        res.writeHead(200, { 'Content-Type': 'application/json' })
+        res.end(
+          JSON.stringify({
+            workspaceId: lastWorkspaceId,
+            sopRules: [
+              { id: 'rule_xyz', toolPattern: 'Bash', action: 'block', reason: 'Blocked in test' }
+            ],
+            dlpPatterns: [],
+            interventionMode: 'BLOCK'
+          })
+        )
+      } else if (url.pathname === '/api/v1/sop/rules') {
+        lastWorkspaceId = url.searchParams.get('workspaceId')
+        res.writeHead(200, { 'Content-Type': 'application/json' })
+        res.end(
+          JSON.stringify({
+            rules: [
+              { id: 'rule_xyz', toolPattern: 'Bash', action: 'block', reason: 'Blocked in test' }
+            ]
+          })
+        )
+      } else if (url.pathname === '/api/v1/hook-events') {
+        let body = ''
+        req.on('data', c => body += c)
+        req.on('end', () => {
+          try {
+            telemetryEvents.push(JSON.parse(body))
+          } catch {}
+          res.writeHead(200, { 'Content-Type': 'application/json' })
+          res.end(JSON.stringify({ ok: true }))
+        })
+      } else {
+        res.writeHead(404)
+        res.end()
+      }
+    })
+
+    await new Promise<void>((resolve) => {
+      mockCp.listen(0, '127.0.0.1', () => {
+        const addr = mockCp.address() as net.AddressInfo | null
+        cpPort = addr?.port ?? 3001
+        process.env['CONTROL_PLANE_URL'] = `http://127.0.0.1:${cpPort}`
+        process.env['INTUTIC_API_KEY'] = 'test-api-key'
+        resolve()
+      })
+    })
+
+    // Start daemon socket server
+    server = createSocketServer()
+    await new Promise<void>((resolve) => server.listen(socketPath, () => resolve()))
+  })
+
+  afterAll(async () => {
+    await new Promise<void>((resolve) => server.close(() => resolve()))
+    await new Promise<void>((resolve) => mockCp.close(() => resolve()))
+    await fs.rm(socketPath, { force: true })
+  })
+
+  it('client callDaemonSocket requests policy.get and gets cached policy', async () => {
+    const res = await callDaemonSocket('policy.get', { workspaceId: 'ws_integration' })
+    expect(res).toBeDefined()
+    expect(res.workspaceId).toBe('ws_integration')
+    expect(res.sopRules).toHaveLength(1)
+    expect(res.sopRules[0].id).toBe('rule_xyz')
+  })
+
+  it('PolicyClient uses daemon when mcpProxyMode is daemon', async () => {
+    const client = new PolicyClient(`http://127.0.0.1:${cpPort}`, 'test-api-key', 'ws_integration', 60000, 'daemon')
+    await client.refresh()
+    const rules = client.getRules()
+    expect(rules).toHaveLength(1)
+    expect(rules[0].id).toBe('rule_xyz')
+  })
+
+  it('GovernanceEmitter enqueues telemetry to daemon', async () => {
+    const emitter = new GovernanceEmitter(`http://127.0.0.1:${cpPort}`, 'test-api-key', 'dummy-path.jsonl', 'ws_integration', 'daemon')
+    emitter.emit('tool_blocked', 'Bash', { args: ['rm -rf'] }, 'Blocked in test')
+    
+    const res = await callDaemonSocket('proxy.health_check', {})
+    expect(res.status).toBe('ok')
+  })
+
+  it('shim client falls back to direct control plane requests if daemon socket is offline', async () => {
+    // Set socket path to invalid location
+    process.env['MCP_DAEMON_SOCKET'] = path.join(os.tmpdir(), `nonexistent-${Date.now()}.sock`)
+    
+    const client = new PolicyClient(`http://127.0.0.1:${cpPort}`, 'test-api-key', 'ws_fallback', 60000, 'daemon')
+    await client.refresh()
+    const rules = client.getRules()
+    expect(rules).toHaveLength(1)
+    expect(rules[0].id).toBe('rule_xyz')
+    expect(lastWorkspaceId).toBe('ws_fallback') // hit CP directly
+    
+    // Restore
+    process.env['MCP_DAEMON_SOCKET'] = socketPath
+  })
+})

package/src/__tests__/interceptor.test.ts

@@ -0,0 +1,229 @@
+/**
+ * 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

@@ -0,0 +1,95 @@
+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

@@ -0,0 +1,220 @@
+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()
+  })
+})