Skip to content

Where agent teams gather. Cross-platform team chat where AI agents are first-class teammates — with cloud or bring-your-own (Claude Code / Codex) brains.

TypeScript
7.0 KB
Raw Blame
import { after, before, beforeEach, test } from 'node:test'
import assert from 'node:assert/strict'
import { createServer, type Server } from 'node:http'
import { pool } from '../db/pool.js'
import { runCli } from '../agents/cli.js'
import { buildApiTestApp, ensureSchemaOnce, resetAllTables, seedCompanyWithAgent, seedUserMembership, teardownAll } from './_helpers.js'

const USER_ID = 'u-due-owner'
let server: Server
let baseUrl = ''

before(async () => {
  await ensureSchemaOnce()
  const app = await buildApiTestApp(USER_ID)
  await new Promise<void>((resolve) => {
    server = createServer(app).listen(0, () => {
      const address = server.address()
      if (address && typeof address === 'object') baseUrl = `http://127.0.0.1:${address.port}`
      resolve()
    })
  })
})
beforeEach(async () => { await resetAllTables() })
after(async () => { await teardownAll(server) })

async function request(companyId: string, path: string, method = 'GET', body?: unknown): Promise<Response> {
  return fetch(`${baseUrl}/api${path}`, {
    method,
    headers: { 'x-company-id': companyId, 'content-type': 'application/json' },
    ...(body === undefined ? {} : { body: JSON.stringify(body) }),
  })
}

test('API and CLI share a date-only value; overdue query distinguishes done and unclassified columns', async () => {
  const { companyId, agentId } = await seedCompanyWithAgent()
  await seedUserMembership(USER_ID, companyId, { email: '[email protected]', displayName: 'Due Owner' })
  const boardCreated = await request(companyId, '/boards', 'POST', { title: 'Deadlines' })
  assert.equal(boardCreated.status, 201)
  const { id: boardId } = await boardCreated.json() as { id: string }
  const board = await (await request(companyId, `/boards/${boardId}`)).json() as {
    columns: Array<{ id: string; kind: string | null }>
  }
  const todo = board.columns.find((column) => column.kind === 'todo')!.id
  const done = board.columns.find((column) => column.kind === 'done')!.id
  const invalidCreate = await request(companyId, `/boards/${boardId}/cards`, 'POST', {
    title: 'Bad deadline', columnId: todo, dueOn: '2026-04-31',
  })
  assert.equal(invalidCreate.status, 400)
  const created = await request(companyId, `/boards/${boardId}/cards`, 'POST', {
    title: 'Send proposal', columnId: todo, dueOn: '2026-09-23',
  })
  assert.equal(created.status, 200)
  const { id: cardId } = await created.json() as { id: string }
  const lookup = await (await request(companyId, `/cards/${cardId}`)).json() as {
    card: { dueOn: string | null }; column: { kind: string | null }
  }
  assert.equal(lookup.card.dueOn, '2026-09-23')
  assert.equal(lookup.column.kind, 'todo')

  const invalid = await request(companyId, `/boards/${boardId}/cards/${cardId}`, 'PATCH', { dueOn: '2026-02-29' })
  assert.equal(invalid.status, 400)
  assert.equal((await request(companyId, `/boards/${boardId}/cards/${cardId}`, 'PATCH', { title: 'Proposal' })).status, 200)
  const unchanged = await (await request(companyId, `/boards/${boardId}`)).json() as { cards: Array<{ dueOn: string | null }> }
  assert.equal(unchanged.cards[0].dueOn, '2026-09-23')

  const overdue = await runCli(['--as', agentId, 'card', 'ls', boardId, '--overdue-as-of', '2026-09-24', '--json'])
  assert.equal(overdue.ok, true, overdue.text)
  assert.deepEqual((JSON.parse(overdue.text) as Array<{ id: string }>).map((card) => card.id), [cardId])
  const moved = await request(companyId, `/boards/${boardId}/cards/${cardId}`, 'PATCH', { columnId: done })
  assert.equal(moved.status, 200)
  const completed = await runCli(['--as', agentId, 'card', 'ls', boardId, '--overdue-as-of', '2026-09-24', '--json'])
  assert.equal(completed.ok, true, completed.text)
  assert.deepEqual(JSON.parse(completed.text), [])

  const otherColumn = await runCli(['--as', agentId, 'kanban', 'add-column', boardId, 'Review'])
  assert.equal(otherColumn.ok, true, otherColumn.text)
  const reviewColumn = (await pool.query<{ id: string }>(
    `SELECT id FROM board_columns WHERE board_id = $1 AND title = 'Review'`, [boardId],
  )).rows[0].id
  const added = await runCli(['--as', agentId, 'card', 'add', boardId, 'Review draft', '--column', reviewColumn, '--due', '2026-09-22'])
  assert.equal(added.ok, true, added.text)
  const reviewCardId = (await pool.query<{ id: string }>(
    `SELECT id FROM board_cards WHERE board_id = $1 AND column_id = $2`, [boardId, reviewColumn],
  )).rows[0].id
  const reviewLookup = await (await request(companyId, `/cards/${reviewCardId}`)).json() as {
    card: { dueOn: string | null }; column: { kind: string | null }
  }
  assert.equal(reviewLookup.card.dueOn, '2026-09-22')
  assert.equal(reviewLookup.column.kind, null)
  const unknownColumn = await runCli(['--as', agentId, 'card', 'ls', boardId, '--overdue-as-of', '2026-09-24', '--json'])
  assert.equal(unknownColumn.ok, true, unknownColumn.text)
  assert.deepEqual(
    (JSON.parse(unknownColumn.text) as Array<{ id: string; column_kind: string | null; due_status: string }>).map((card) => [card.id, card.column_kind, card.due_status]),
    [[reviewCardId, null, 'status_unknown']],
  )
  const unknownText = await runCli(['--as', agentId, 'card', 'ls', boardId, '--overdue-as-of', '2026-09-24'])
  assert.match(unknownText.text, /column status unknown/)
  assert.equal((await request(companyId, `/boards/${boardId}/columns/${reviewColumn}`, 'PATCH', { kind: 'done' })).status, 200)
  const classifiedDone = await runCli(['--as', agentId, 'card', 'ls', boardId, '--overdue-as-of', '2026-09-24', '--json'])
  assert.deepEqual(JSON.parse(classifiedDone.text), [])
  assert.equal((await request(companyId, `/boards/${boardId}/columns/${reviewColumn}`, 'PATCH', { kind: 'doing' })).status, 200)
  const classifiedDoing = await runCli(['--as', agentId, 'card', 'ls', boardId, '--overdue-as-of', '2026-09-24', '--json'])
  assert.deepEqual(
    (JSON.parse(classifiedDoing.text) as Array<{ id: string; due_status: string }>).map((card) => [card.id, card.due_status]),
    [[reviewCardId, 'overdue']],
  )

  const apiClear = await request(companyId, `/boards/${boardId}/cards/${cardId}`, 'PATCH', { dueOn: null })
  assert.equal(apiClear.status, 200)
  const clearedByApi = await (await request(companyId, `/cards/${cardId}`)).json() as { card: { dueOn: string | null } }
  assert.equal(clearedByApi.card.dueOn, null)

  const set = await runCli(['--as', agentId, 'card', 'due', cardId, '2026-09-25'])
  assert.equal(set.ok, true, set.text)
  assert.deepEqual(set.sideEffects, [{
    event: 'kanban.card_updated', command: 'card due', boardId, cardId,
    actorId: agentId, companyId, dueOn: '2026-09-25', visibleToUser: true,
  }])
  assert.equal((await pool.query<{ due_on: string | null }>(`SELECT due_on::text AS due_on FROM board_cards WHERE id = $1`, [cardId])).rows[0].due_on, '2026-09-25')
  const clear = await runCli(['--as', agentId, 'card', 'due', cardId, 'clear'])
  assert.equal(clear.ok, true, clear.text)
  assert.equal(clear.sideEffects?.[0]?.event, 'kanban.card_updated')
  assert.equal((await pool.query<{ due_on: string | null }>(`SELECT due_on::text AS due_on FROM board_cards WHERE id = $1`, [cardId])).rows[0].due_on, null)
})