@andypai/agent-kanban 0.2.0 → 0.3.1

package/src/__tests__/mcp-server.test.ts

@@ -0,0 +1,252 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import { Database } from 'bun:sqlite'
+import { Client } from '@modelcontextprotocol/sdk/client'
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js'
+import { addTask, initSchema, seedDefaultColumns } from '../db'
+import { createTrackerCore, createTrackerMcpServer, TrackerMcpError } from '../mcp/index'
+import { LocalProvider } from '../providers/local'
+
+interface TestScope {
+  actor: string
+}
+
+let db: Database
+let provider: LocalProvider
+
+beforeEach(() => {
+  db = new Database(':memory:')
+  db.run('PRAGMA foreign_keys = ON')
+  initSchema(db)
+  seedDefaultColumns(db)
+  provider = new LocalProvider(db, ':memory:')
+})
+
+afterEach(() => {
+  db.close()
+})
+
+function initializeBody() {
+  return {
+    jsonrpc: '2.0',
+    id: 1,
+    method: 'initialize',
+    params: {
+      protocolVersion: '2025-03-26',
+      capabilities: {},
+      clientInfo: {
+        name: 'agent-kanban-test-client',
+        version: '1.0.0',
+      },
+    },
+  }
+}
+
+function startTrackerServer(
+  policyOverrides: Partial<Parameters<typeof createTrackerCore<TestScope>>[0]['policy']> = {},
+) {
+  const core = createTrackerCore<TestScope>({
+    provider,
+    policy: {
+      canReadTicket() {},
+      canPostComment() {},
+      canUpdateComment() {},
+      canMoveTicket() {},
+      ...policyOverrides,
+    },
+  })
+
+  const tracker = createTrackerMcpServer({
+    core,
+    auth: async ({ headers }) => {
+      const authHeader = headers.get('authorization')
+      if (authHeader !== 'Bearer good-token') {
+        throw new TrackerMcpError({
+          code: 'auth_failed',
+          publicMessage: 'unauthenticated',
+        })
+      }
+      return { actor: 'tester' }
+    },
+  })
+
+  const httpServer = Bun.serve({
+    port: 0,
+    fetch(request) {
+      return tracker.fetch(request)
+    },
+  })
+
+  const url = new URL(`http://127.0.0.1:${httpServer.port}/mcp`)
+
+  return {
+    core,
+    tracker,
+    httpServer,
+    url,
+    async close() {
+      await tracker.close()
+      httpServer.stop(true)
+    },
+  }
+}
+
+describe('createTrackerMcpServer', () => {
+  test('serves tools over Streamable HTTP and round-trips a tool call through auth, policy, and provider', async () => {
+    const task = addTask(db, 'MCP task')
+    const runtime = startTrackerServer()
+    const transport = new StreamableHTTPClientTransport(runtime.url, {
+      requestInit: { headers: { Authorization: 'Bearer good-token' } },
+    })
+    const client = new Client({ name: 'test-client', version: '1.0.0' })
+
+    try {
+      await client.connect(transport)
+      const tools = await client.listTools()
+      expect(tools.tools.map((tool) => tool.name)).toEqual([
+        'getTicket',
+        'listComments',
+        'getBoard',
+        'postComment',
+        'updateComment',
+        'moveTicket',
+      ])
+
+      const result = await client.callTool({
+        name: 'getTicket',
+        arguments: { ticketId: task.id },
+      })
+
+      expect(
+        (result.structuredContent as { result: { id: string; title: string } }).result,
+      ).toEqual(
+        expect.objectContaining({
+          id: task.id,
+          title: 'MCP task',
+        }),
+      )
+    } finally {
+      await client.close()
+      await runtime.close()
+    }
+  })
+
+  test('round-trips updateComment end-to-end, handing the existing comment to the policy', async () => {
+    const task = addTask(db, 'MCP task')
+    const created = await provider.comment(task.id, 'original body')
+    const seenExisting: { id?: string; body?: string } = {}
+    const runtime = startTrackerServer({
+      canUpdateComment(_scope, _ticketId, comment) {
+        seenExisting.id = comment.id
+        seenExisting.body = comment.body
+      },
+    })
+    const transport = new StreamableHTTPClientTransport(runtime.url, {
+      requestInit: { headers: { Authorization: 'Bearer good-token' } },
+    })
+    const client = new Client({ name: 'test-client', version: '1.0.0' })
+
+    try {
+      await client.connect(transport)
+      const result = await client.callTool({
+        name: 'updateComment',
+        arguments: { ticketId: task.id, commentId: created.id, body: 'rewritten' },
+      })
+      expect((result.structuredContent as { result: { id: string; body: string } }).result).toEqual(
+        expect.objectContaining({
+          id: created.id,
+          body: 'rewritten',
+        }),
+      )
+      expect(seenExisting).toEqual({ id: created.id, body: 'original body' })
+    } finally {
+      await client.close()
+      await runtime.close()
+    }
+  })
+
+  test('returns HTTP 401 before session creation when auth fails', async () => {
+    const runtime = startTrackerServer()
+
+    try {
+      const response = await fetch(runtime.url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(initializeBody()),
+      })
+      const body = (await response.json()) as {
+        error: { code: number; message: string }
+      }
+
+      expect(response.status).toBe(401)
+      expect(body.error).toEqual({
+        code: -32001,
+        message: 'unauthenticated',
+      })
+    } finally {
+      await runtime.close()
+    }
+  })
+
+  test('surfaces policy denial as a JSON-RPC error during tool calls', async () => {
+    const task = addTask(db, 'MCP task')
+    const runtime = startTrackerServer({
+      canMoveTicket() {
+        throw new TrackerMcpError({
+          code: 'policy_denied',
+          publicMessage: 'forbidden_column',
+        })
+      },
+    })
+    const transport = new StreamableHTTPClientTransport(runtime.url, {
+      requestInit: { headers: { Authorization: 'Bearer good-token' } },
+    })
+    const client = new Client({ name: 'test-client', version: '1.0.0' })
+
+    try {
+      await client.connect(transport)
+      try {
+        await client.callTool({
+          name: 'moveTicket',
+          arguments: { ticketId: task.id, column: 'done' },
+        })
+        throw new Error('Expected moveTicket to fail')
+      } catch (error) {
+        const mcpError = error as { code?: number; message?: string }
+        expect(mcpError.code).toBe(-32002)
+        expect(mcpError.message).toContain('forbidden_column')
+      }
+    } finally {
+      await client.close()
+      await runtime.close()
+    }
+  })
+
+  test('rejects new requests after close()', async () => {
+    const runtime = startTrackerServer()
+
+    try {
+      await runtime.tracker.selfPing()
+      await runtime.tracker.close()
+
+      const response = await fetch(runtime.url, {
+        method: 'POST',
+        headers: {
+          Authorization: 'Bearer good-token',
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(initializeBody()),
+      })
+      const body = (await response.json()) as {
+        error: { code: number; message: string }
+      }
+
+      expect(response.status).toBe(503)
+      expect(body.error).toEqual({
+        code: -32000,
+        message: 'Tracker MCP server is closed',
+      })
+    } finally {
+      runtime.httpServer.stop(true)
+    }
+  })
+})

package/src/__tests__/metrics.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test, beforeEach } from 'bun:test'
 import { Database } from 'bun:sqlite'
-import { initSchema, seedDefaultColumns, addTask } from '../db.ts'
-import { getBoardMetrics } from '../metrics.ts'
+import { initSchema, seedDefaultColumns, addTask } from '../db'
+import { getBoardMetrics } from '../metrics'
 
 let db: Database
 

package/src/__tests__/output.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'bun:test'
-import { success, error, formatOutput } from '../output.ts'
+import { success, error, formatOutput } from '../output'
 
 describe('success', () => {
   test('wraps data in ok envelope', () => {

package/src/__tests__/provider-capabilities.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, test } from 'bun:test'
+
+import {
+  JIRA_CAPABILITIES,
+  LINEAR_CAPABILITIES,
+  LOCAL_CAPABILITIES,
+} from '../providers/capabilities'
+
+describe('provider capabilities', () => {
+  test('remote providers share the same read/write baseline', () => {
+    expect(LINEAR_CAPABILITIES).toEqual(JIRA_CAPABILITIES)
+    expect(LINEAR_CAPABILITIES).toEqual({
+      taskCreate: true,
+      taskUpdate: true,
+      taskMove: true,
+      taskDelete: false,
+      comment: true,
+      activity: false,
+      metrics: false,
+      columnCrud: false,
+      bulk: false,
+      configEdit: false,
+    })
+  })
+
+  test('local provider exposes the full local board surface', () => {
+    expect(LOCAL_CAPABILITIES).toEqual({
+      taskCreate: true,
+      taskUpdate: true,
+      taskMove: true,
+      taskDelete: true,
+      comment: true,
+      activity: true,
+      metrics: true,
+      columnCrud: true,
+      bulk: true,
+      configEdit: true,
+    })
+  })
+})

package/src/__tests__/server.test.ts

@@ -0,0 +1,291 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+import type { BoardBootstrap, BoardConfig, BoardMetrics, BoardView, Column, Task } from '../types'
+import { startServer, type StartedServer } from '../server'
+import type {
+  CreateTaskInput,
+  KanbanProvider,
+  ProviderContext,
+  ProviderSyncStatus,
+  TaskListFilters,
+  UpdateTaskInput,
+} from '../providers/types'
+
+const emptyBoard: BoardView = { columns: [] }
+const emptyConfig: BoardConfig = { members: [], projects: [], provider: 'local' }
+const noopTask = (): Task => ({
+  id: 't1',
+  providerId: 't1',
+  externalRef: 't1',
+  url: null,
+  title: 'Task',
+  description: '',
+  column_id: 'backlog',
+  position: 0,
+  priority: 'medium',
+  assignee: '',
+  assignees: [],
+  labels: [],
+  comment_count: 0,
+  project: '',
+  metadata: '{}',
+  created_at: '2026-04-22T00:00:00.000Z',
+  updated_at: '2026-04-22T00:00:00.000Z',
+  version: '1',
+  source_updated_at: null,
+})
+const noopMetrics = (): BoardMetrics => ({
+  tasksByColumn: [],
+  tasksByPriority: [],
+  totalTasks: 0,
+  completedTasks: 0,
+  avgCompletionHours: null,
+  recentActivity: [],
+  tasksCreatedThisWeek: 0,
+  inProgressCount: 0,
+  completionPercent: 0,
+  assignees: [],
+  projects: [],
+})
+
+function makeProvider(overrides: Partial<KanbanProvider> = {}): KanbanProvider {
+  const provider: KanbanProvider = {
+    type: 'local',
+    async getContext(): Promise<ProviderContext> {
+      return {
+        provider: provider.type,
+        capabilities: {
+          taskCreate: true,
+          taskUpdate: true,
+          taskMove: true,
+          taskDelete: true,
+          comment: true,
+          activity: true,
+          metrics: true,
+          columnCrud: true,
+          bulk: true,
+          configEdit: true,
+        },
+        team: null,
+      }
+    },
+    async getBootstrap(): Promise<BoardBootstrap> {
+      return {
+        provider: provider.type,
+        capabilities: (await provider.getContext()).capabilities,
+        board: emptyBoard,
+        config: emptyConfig,
+        metrics: null,
+        activity: [],
+        team: null,
+      }
+    },
+    async getBoard(): Promise<BoardView> {
+      return emptyBoard
+    },
+    async listColumns(): Promise<Column[]> {
+      return []
+    },
+    async listTasks(_filters?: TaskListFilters): Promise<Task[]> {
+      return []
+    },
+    async getTask(_idOrRef: string): Promise<Task> {
+      return noopTask()
+    },
+    async createTask(_input: CreateTaskInput): Promise<Task> {
+      return noopTask()
+    },
+    async updateTask(_idOrRef: string, _input: UpdateTaskInput): Promise<Task> {
+      return noopTask()
+    },
+    async moveTask(_idOrRef: string, _column: string): Promise<Task> {
+      return noopTask()
+    },
+    async deleteTask(_idOrRef: string): Promise<Task> {
+      return noopTask()
+    },
+    async listComments(): Promise<[]> {
+      return []
+    },
+    async getComment() {
+      return {
+        id: 'c1',
+        task_id: 't1',
+        body: '',
+        author: null,
+        created_at: '2026-04-22T00:00:00.000Z',
+        updated_at: '2026-04-22T00:00:00.000Z',
+      }
+    },
+    async comment() {
+      return {
+        id: 'c1',
+        task_id: 't1',
+        body: '',
+        author: null,
+        created_at: '2026-04-22T00:00:00.000Z',
+        updated_at: '2026-04-22T00:00:00.000Z',
+      }
+    },
+    async updateComment() {
+      return {
+        id: 'c1',
+        task_id: 't1',
+        body: '',
+        author: null,
+        created_at: '2026-04-22T00:00:00.000Z',
+        updated_at: '2026-04-22T00:00:00.000Z',
+      }
+    },
+    async getActivity() {
+      return []
+    },
+    async getMetrics(): Promise<BoardMetrics> {
+      return noopMetrics()
+    },
+    async getConfig(): Promise<BoardConfig> {
+      return emptyConfig
+    },
+    async patchConfig(): Promise<BoardConfig> {
+      return emptyConfig
+    },
+    ...overrides,
+  }
+  return provider
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+const runtimes: StartedServer[] = []
+
+afterEach(() => {
+  while (runtimes.length > 0) {
+    runtimes.pop()?.stop(true)
+  }
+})
+
+describe('startServer', () => {
+  test('health is cheap and does not call getContext', async () => {
+    let getContextCalls = 0
+    const runtime = startServer(
+      makeProvider({
+        async getContext() {
+          getContextCalls += 1
+          return {
+            provider: 'local',
+            capabilities: {
+              taskCreate: true,
+              taskUpdate: true,
+              taskMove: true,
+              taskDelete: true,
+              comment: true,
+              activity: true,
+              metrics: true,
+              columnCrud: true,
+              bulk: true,
+              configEdit: true,
+            },
+            team: null,
+          }
+        },
+      }),
+      0,
+    )
+    runtimes.push(runtime)
+
+    const response = await fetch(`http://127.0.0.1:${runtime.port}/api/health`)
+    const body = (await response.json()) as {
+      ok: boolean
+      data: { provider: string; status: string; wsClients: number }
+    }
+
+    expect(response.status).toBe(200)
+    expect(body.ok).toBe(true)
+    expect(body.data.provider).toBe('local')
+    expect(getContextCalls).toBe(0)
+  })
+
+  test('ready stays false until the first background sync succeeds', async () => {
+    let resolveSync!: () => void
+    const runtime = startServer(
+      makeProvider({
+        type: 'linear',
+        async syncCache() {
+          await new Promise<void>((resolve) => {
+            resolveSync = resolve
+          })
+        },
+      }),
+      0,
+      { syncIntervalMs: 20 },
+    )
+    runtimes.push(runtime)
+
+    await sleep(5)
+    let response = await fetch(`http://127.0.0.1:${runtime.port}/api/ready`)
+    expect(response.status).toBe(503)
+
+    resolveSync()
+    await sleep(5)
+    response = await fetch(`http://127.0.0.1:${runtime.port}/api/ready`)
+    expect(response.status).toBe(200)
+    const body = (await response.json()) as {
+      ok: boolean
+      data: { ready: boolean; backgroundSync: { warm: boolean } }
+    }
+    expect(body.ok).toBe(true)
+    expect(body.data.ready).toBe(true)
+    expect(body.data.backgroundSync.warm).toBe(true)
+  })
+
+  test('sync-status reports provider sync metadata and background scheduler state', async () => {
+    let syncCalls = 0
+    let providerSync: ProviderSyncStatus = {
+      lastSyncAt: null,
+      lastFullSyncAt: null,
+      lastWebhookAt: null,
+    }
+
+    const runtime = startServer(
+      makeProvider({
+        type: 'jira',
+        async syncCache() {
+          syncCalls += 1
+          const now = new Date().toISOString()
+          providerSync = {
+            lastSyncAt: now,
+            lastFullSyncAt: syncCalls === 1 ? now : providerSync.lastFullSyncAt,
+            lastWebhookAt: providerSync.lastWebhookAt,
+          }
+        },
+        async getSyncStatus() {
+          return providerSync
+        },
+      }),
+      0,
+      { syncIntervalMs: 20 },
+    )
+    runtimes.push(runtime)
+
+    await sleep(55)
+    const response = await fetch(`http://127.0.0.1:${runtime.port}/api/sync-status`)
+    const body = (await response.json()) as {
+      ok: boolean
+      data: {
+        provider: string
+        backgroundSync: { enabled: boolean; warm: boolean; lastSuccessAt: string | null }
+        providerSync: ProviderSyncStatus
+      }
+    }
+
+    expect(response.status).toBe(200)
+    expect(body.ok).toBe(true)
+    expect(body.data.provider).toBe('jira')
+    expect(body.data.backgroundSync.enabled).toBe(true)
+    expect(body.data.backgroundSync.warm).toBe(true)
+    expect(body.data.backgroundSync.lastSuccessAt).not.toBeNull()
+    expect(body.data.providerSync.lastSyncAt).not.toBeNull()
+    expect(syncCalls).toBeGreaterThanOrEqual(2)
+  })
+})