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
21.5 KB
Raw Blame
import assert from 'node:assert/strict'
import { createHash } from 'node:crypto'
import { createServer, type Server } from 'node:http'
import { after, before, beforeEach, test } from 'node:test'
import { pool } from '../db/pool.js'
import { isRuntimeAgentAuthorized } from '../agents/runtime/authorization.js'
import { drainWorkspaceCleanupJobs } from '../workspace-cleanup.js'
import { buildApiTestApp, ensureSchemaOnce, resetAllTables, teardownAll } from './_helpers.js'

const OWNER_ID = 'u-workspace-owner'
const TARGET_ID = 'u-workspace-target'
let ownerServer: Server
let targetServer: Server
let ownerBase = ''
let targetBase = ''

async function listenFor(userId: string): Promise<{ server: Server; base: string }> {
  const app = await buildApiTestApp(userId)
  return new Promise((resolve) => {
    const server = createServer(app).listen(0, () => {
      const address = server.address()
      assert.ok(address && typeof address === 'object')
      resolve({ server, base: `http://127.0.0.1:${address.port}` })
    })
  })
}

before(async () => {
  await ensureSchemaOnce()
  const owner = await listenFor(OWNER_ID)
  ownerServer = owner.server
  ownerBase = owner.base
  const target = await listenFor(TARGET_ID)
  targetServer = target.server
  targetBase = target.base
})

beforeEach(async () => {
  await resetAllTables()
})

after(async () => {
  if (ownerServer?.listening) await new Promise<void>((resolve) => ownerServer.close(() => resolve()))
  await teardownAll(targetServer)
})

async function seedUser(userId: string): Promise<void> {
  await pool.query(
    `INSERT INTO users (id, email, display_name, tier)
     VALUES ($1, $2, $3, 'pro')`,
    [userId, `${userId}@test.local`, userId],
  )
}

async function seedCompany(companyId: string, ownerId: string): Promise<void> {
  await pool.query(
    `INSERT INTO companies (id, name, slug, owner_user_id)
     VALUES ($1, $2, $3, $4)`,
    [companyId, `Workspace ${companyId}`, companyId, ownerId],
  )
}

async function seedMember(
  companyId: string,
  userId: string,
  role: 'owner' | 'admin' | 'member',
): Promise<void> {
  const exists = await pool.query(`SELECT 1 FROM users WHERE id = $1`, [userId])
  if (!exists.rows[0]) await seedUser(userId)
  await pool.query(
    `INSERT INTO company_members (company_id, user_id, role) VALUES ($1, $2, $3)`,
    [companyId, userId, role],
  )
  await pool.query(
    `INSERT INTO participants
       (id, company_id, kind, name, role, initial, avatar_bg, status)
     VALUES ($1, $2, 'human', $3, NULL, $4, '#abcdef', 'avail')`,
    [userId, companyId, userId, userId.charAt(0).toUpperCase()],
  )
}

async function seedOwnedWorkspace(companyId = 'co-managed'): Promise<void> {
  await seedUser(OWNER_ID)
  await seedCompany(companyId, OWNER_ID)
  await seedMember(companyId, OWNER_ID, 'owner')
}

function companyHeaders(companyId: string): Record<string, string> {
  return { 'content-type': 'application/json', 'x-company-id': companyId }
}

test('[integration] owner lists members and changes a member role', async () => {
  await seedOwnedWorkspace()
  await seedMember('co-managed', TARGET_ID, 'member')

  const list = await fetch(`${ownerBase}/api/companies/co-managed/members`, {
    headers: companyHeaders('co-managed'),
  })
  assert.equal(list.status, 200)
  const members = await list.json() as Array<{ id: string; role: string; email: string }>
  assert.deepEqual(members.map((row) => [row.id, row.role]), [
    [OWNER_ID, 'owner'],
    [TARGET_ID, 'member'],
  ])
  assert.equal(members[1].email, `${TARGET_ID}@test.local`)

  const update = await fetch(`${ownerBase}/api/companies/co-managed/members/${TARGET_ID}`, {
    method: 'PATCH', headers: companyHeaders('co-managed'), body: JSON.stringify({ role: 'admin' }),
  })
  assert.equal(update.status, 200)
  const stored = await pool.query<{ role: string }>(
    `SELECT role FROM company_members WHERE company_id = 'co-managed' AND user_id = $1`,
    [TARGET_ID],
  )
  assert.equal(stored.rows[0].role, 'admin')
  const event = await pool.query<{ payload: { kind: string; recipientUserIds: string[] } }>(
    `SELECT payload FROM realtime_outbox WHERE channel = 'cumora:workspaces'`,
  )
  assert.equal(event.rows[0].payload.kind, 'role_changed')
  assert.deepEqual(new Set(event.rows[0].payload.recipientUserIds), new Set([OWNER_ID, TARGET_ID]))
})

test('[integration] admin cannot change roles or remove another admin', async () => {
  const realOwner = 'u-real-owner'
  await seedUser(realOwner)
  await seedCompany('co-admin', realOwner)
  await seedMember('co-admin', realOwner, 'owner')
  await seedMember('co-admin', OWNER_ID, 'admin')
  await seedMember('co-admin', TARGET_ID, 'admin')

  const update = await fetch(`${ownerBase}/api/companies/co-admin/members/${TARGET_ID}`, {
    method: 'PATCH', headers: companyHeaders('co-admin'), body: JSON.stringify({ role: 'member' }),
  })
  assert.equal(update.status, 403)

  const remove = await fetch(`${ownerBase}/api/companies/co-admin/members/${TARGET_ID}`, {
    method: 'DELETE', headers: companyHeaders('co-admin'),
  })
  assert.equal(remove.status, 403)
})

test('[integration] regular members cannot list, change, or remove workspace members', async () => {
  await seedOwnedWorkspace()
  await seedMember('co-managed', TARGET_ID, 'member')

  const list = await fetch(`${targetBase}/api/companies/co-managed/members`, {
    headers: companyHeaders('co-managed'),
  })
  assert.equal(list.status, 403)
  const update = await fetch(`${targetBase}/api/companies/co-managed/members/${OWNER_ID}`, {
    method: 'PATCH', headers: companyHeaders('co-managed'), body: JSON.stringify({ role: 'member' }),
  })
  assert.equal(update.status, 403)
  const remove = await fetch(`${targetBase}/api/companies/co-managed/members/${OWNER_ID}`, {
    method: 'DELETE', headers: companyHeaders('co-managed'),
  })
  assert.equal(remove.status, 403)
})

test('[integration] admin can remove a member but cannot invite an admin', async () => {
  const realOwner = 'u-real-owner'
  await seedUser(realOwner)
  await seedCompany('co-admin', realOwner)
  await seedMember('co-admin', realOwner, 'owner')
  await seedMember('co-admin', OWNER_ID, 'admin')
  await seedMember('co-admin', TARGET_ID, 'member')

  const invite = await fetch(`${ownerBase}/api/companies/co-admin/invitations`, {
    method: 'POST', headers: companyHeaders('co-admin'),
    body: JSON.stringify({ email: '[email protected]', role: 'admin' }),
  })
  assert.equal(invite.status, 403)
  const remove = await fetch(`${ownerBase}/api/companies/co-admin/members/${TARGET_ID}`, {
    method: 'DELETE', headers: companyHeaders('co-admin'),
  })
  assert.equal(remove.status, 200)
})

test('[integration] workspace owner and self-removal protections are enforced', async () => {
  await seedOwnedWorkspace()
  await seedMember('co-managed', TARGET_ID, 'member')

  const patchOwner = await fetch(`${ownerBase}/api/companies/co-managed/members/${OWNER_ID}`, {
    method: 'PATCH', headers: companyHeaders('co-managed'), body: JSON.stringify({ role: 'member' }),
  })
  assert.equal(patchOwner.status, 409)
  const removeSelf = await fetch(`${targetBase}/api/companies/co-managed/members/${TARGET_ID}`, {
    method: 'DELETE', headers: companyHeaders('co-managed'),
  })
  assert.equal(removeSelf.status, 409)

  const realOwner = 'u-real-owner'
  await seedUser(realOwner)
  await seedCompany('co-admin', realOwner)
  await seedMember('co-admin', realOwner, 'owner')
  await seedMember('co-admin', OWNER_ID, 'admin')
  const removeOwner = await fetch(`${ownerBase}/api/companies/co-admin/members/${realOwner}`, {
    method: 'DELETE', headers: companyHeaders('co-admin'),
  })
  assert.equal(removeOwner.status, 409)
})

test('[integration] workspace management is tenant scoped', async () => {
  const ownerA = 'u-owner-a'
  await seedUser(ownerA)
  await seedCompany('co-a', ownerA)
  await seedMember('co-a', ownerA, 'owner')
  await seedMember('co-a', OWNER_ID, 'admin')
  const otherOwner = 'u-other-owner'
  await seedUser(otherOwner)
  await seedCompany('co-other', otherOwner)
  await seedMember('co-other', otherOwner, 'owner')

  const list = await fetch(`${ownerBase}/api/companies/co-other/members`, {
    headers: companyHeaders('co-other'),
  })
  assert.equal(list.status, 403)
  const update = await fetch(`${ownerBase}/api/companies/co-other/members/${otherOwner}`, {
    method: 'PATCH', headers: companyHeaders('co-other'), body: JSON.stringify({ role: 'member' }),
  })
  assert.equal(update.status, 403)
  const remove = await fetch(`${ownerBase}/api/companies/co-other/members/${otherOwner}`, {
    method: 'DELETE', headers: companyHeaders('co-other'),
  })
  assert.equal(remove.status, 403)
})

test('[integration] removing a member revokes tenant and conversation access atomically', async () => {
  await seedOwnedWorkspace()
  await seedMember('co-managed', TARGET_ID, 'member')
  await pool.query(
    `INSERT INTO conversations (id, kind, title, members, company_id)
     VALUES ('room-managed', 'group', 'Managed room', $1::jsonb, 'co-managed')`,
    [JSON.stringify([OWNER_ID, TARGET_ID])],
  )
  await pool.query(
    `INSERT INTO user_preferences (user_id, prefs, company_id)
     VALUES ($1, '{"theme":"dark"}'::jsonb, 'personal')`, [TARGET_ID],
  )
  await pool.query(
    `INSERT INTO agent_autonomy (user_id, agent_id, company_id)
     VALUES ($1, 'global-agent', 'personal')`, [TARGET_ID],
  )

  const remove = await fetch(`${ownerBase}/api/companies/co-managed/members/${TARGET_ID}`, {
    method: 'DELETE', headers: companyHeaders('co-managed'),
  })
  assert.equal(remove.status, 200)

  const membership = await pool.query(
    `SELECT 1 FROM company_members WHERE company_id = 'co-managed' AND user_id = $1`, [TARGET_ID],
  )
  assert.equal(membership.rowCount, 0)
  const participant = await pool.query<{ departed_at: Date | null }>(
    `SELECT departed_at FROM participants WHERE company_id = 'co-managed' AND id = $1`, [TARGET_ID],
  )
  assert.ok(participant.rows[0].departed_at)
  const conversation = await pool.query<{ members: string[] }>(
    `SELECT members FROM conversations WHERE id = 'room-managed'`,
  )
  assert.deepEqual(conversation.rows[0].members, [OWNER_ID])
  const normalized = await pool.query<{ participant_id: string }>(
    `SELECT participant_id FROM conversation_members
      WHERE conversation_id = 'room-managed' ORDER BY ordinal`,
  )
  assert.deepEqual(normalized.rows.map((row) => row.participant_id), [OWNER_ID])
  assert.equal((await pool.query(`SELECT 1 FROM user_preferences WHERE user_id = $1`, [TARGET_ID])).rowCount, 1)
  assert.equal((await pool.query(`SELECT 1 FROM agent_autonomy WHERE user_id = $1`, [TARGET_ID])).rowCount, 1)
  const event = await pool.query<{ payload: { kind: string; recipientUserIds: string[] } }>(
    `SELECT payload FROM realtime_outbox WHERE channel = 'cumora:workspaces'`,
  )
  assert.equal(event.rows[0].payload.kind, 'removed')
  assert.deepEqual(new Set(event.rows[0].payload.recipientUserIds), new Set([OWNER_ID, TARGET_ID]))

  const denied = await fetch(`${targetBase}/api/participants`, {
    headers: companyHeaders('co-managed'),
  })
  assert.equal(denied.status, 403)
})

test('[integration] removing and reinviting a member preserves and reuses direct messages', async () => {
  await seedOwnedWorkspace()
  await seedMember('co-managed', TARGET_ID, 'member')
  await pool.query(
    `INSERT INTO conversations (id, kind, title, members, company_id)
     VALUES ('direct-managed', 'direct', 'Direct room', $1::jsonb, 'co-managed')`,
    [JSON.stringify([OWNER_ID, TARGET_ID])],
  )

  const remove = await fetch(`${ownerBase}/api/companies/co-managed/members/${TARGET_ID}`, {
    method: 'DELETE', headers: companyHeaders('co-managed'),
  })
  assert.equal(remove.status, 200)
  const retained = await pool.query<{ participant_id: string }>(
    `SELECT participant_id FROM conversation_members
      WHERE conversation_id = 'direct-managed' ORDER BY ordinal`,
  )
  assert.deepEqual(retained.rows.map((row) => row.participant_id), [OWNER_ID, TARGET_ID])

  const rawToken = 'workspace-direct-reinvite-token'
  const tokenHash = createHash('sha256').update(rawToken).digest('base64url')
  await pool.query(
    `INSERT INTO company_invitations
       (token_hash, company_id, invited_by, email, role, max_uses, expires_at)
     VALUES ($1, 'co-managed', $2, $3, 'member', 1, NOW() + INTERVAL '1 day')`,
    [tokenHash, OWNER_ID, `${TARGET_ID}@test.local`],
  )
  const accept = await fetch(`${targetBase}/api/invitations/${rawToken}/accept`, {
    method: 'POST', headers: { 'content-type': 'application/json' }, body: '{}',
  })
  assert.equal(accept.status, 200)
  const directCount = await pool.query<{ count: number }>(
    `SELECT COUNT(*)::int AS count FROM conversations WHERE company_id = 'co-managed' AND kind = 'direct'`,
  )
  assert.equal(directCount.rows[0].count, 1)
})

test('[integration] a removed member can accept a new invite and becomes active again', async () => {
  await seedOwnedWorkspace()
  await seedMember('co-managed', TARGET_ID, 'member')
  const remove = await fetch(`${ownerBase}/api/companies/co-managed/members/${TARGET_ID}`, {
    method: 'DELETE', headers: companyHeaders('co-managed'),
  })
  assert.equal(remove.status, 200)

  const rawToken = 'workspace-reinvite-token'
  const tokenHash = createHash('sha256').update(rawToken).digest('base64url')
  await pool.query(
    `INSERT INTO company_invitations
       (token_hash, company_id, invited_by, email, role, max_uses, expires_at)
     VALUES ($1, 'co-managed', $2, $3, 'member', 1, NOW() + INTERVAL '1 day')`,
    [tokenHash, OWNER_ID, `${TARGET_ID}@test.local`],
  )

  const accept = await fetch(`${targetBase}/api/invitations/${rawToken}/accept`, {
    method: 'POST', headers: { 'content-type': 'application/json' }, body: '{}',
  })
  assert.equal(accept.status, 200)
  const participant = await pool.query<{ departed_at: Date | null; status: string }>(
    `SELECT departed_at, status FROM participants WHERE company_id = 'co-managed' AND id = $1`,
    [TARGET_ID],
  )
  assert.equal(participant.rows[0].departed_at, null)
  assert.equal(participant.rows[0].status, 'avail')
})

test('[integration] owner cannot delete their only workspace', async () => {
  await seedOwnedWorkspace()
  const response = await fetch(`${ownerBase}/api/companies/co-managed`, {
    method: 'DELETE', headers: companyHeaders('co-managed'),
    body: JSON.stringify({ confirmation: 'Workspace co-managed' }),
  })
  assert.equal(response.status, 409)
  const company = await pool.query(`SELECT 1 FROM companies WHERE id = 'co-managed'`)
  assert.equal(company.rowCount, 1)
})

test('[integration] only the owner with an exact confirmation can delete a workspace', async () => {
  await seedOwnedWorkspace()
  await seedCompany('co-alternative', OWNER_ID)
  await seedMember('co-alternative', OWNER_ID, 'owner')
  await seedMember('co-managed', TARGET_ID, 'member')

  for (const body of [{}, { confirmation: 'wrong name' }]) {
    const response = await fetch(`${ownerBase}/api/companies/co-managed`, {
      method: 'DELETE', headers: companyHeaders('co-managed'), body: JSON.stringify(body),
    })
    assert.equal(response.status, 400)
  }
  const nonOwner = await fetch(`${targetBase}/api/companies/co-managed`, {
    method: 'DELETE', headers: companyHeaders('co-managed'),
    body: JSON.stringify({ confirmation: 'Workspace co-managed' }),
  })
  assert.equal(nonOwner.status, 403)
  const company = await pool.query(`SELECT 1 FROM companies WHERE id = 'co-managed'`)
  assert.equal(company.rowCount, 1)
})

test('[integration] workspace deletion purges FK-backed and legacy soft-scoped data', async () => {
  await seedOwnedWorkspace()
  await seedCompany('co-alternative', OWNER_ID)
  await seedMember('co-alternative', OWNER_ID, 'owner')
  await seedMember('co-managed', TARGET_ID, 'member')
  await pool.query(
    `INSERT INTO participants
       (id, company_id, kind, name, role, initial, avatar_bg, status, system_prompt)
     VALUES ('agent-managed', 'co-managed', 'agent', 'Managed agent', 'ops', 'M', '#abcdef', 'avail', 'test')`,
  )
  await pool.query(
    `INSERT INTO conversations (id, kind, title, members, company_id)
     VALUES ('room-managed', 'group', 'Managed room', $1::jsonb, 'co-managed')`,
    [JSON.stringify([OWNER_ID, TARGET_ID, 'agent-managed'])],
  )
  await pool.query(
    `INSERT INTO messages (id, conversation_id, author_id, kind, body, sequence, company_id)
     VALUES ('msg-managed', 'room-managed', $1, 'text', 'history', 1, 'co-managed')`,
    [TARGET_ID],
  )
  await pool.query(
    `INSERT INTO documents (id, company_id, title, created_by)
     VALUES ('doc-managed', 'co-managed', 'Managed doc', $1)`, [OWNER_ID],
  )
  await pool.query(
    `INSERT INTO computers (id, company_id, name, kind)
     VALUES ('computer-managed', 'co-managed', 'Managed computer', 'local')`,
  )
  await pool.query(
    `INSERT INTO agent_runs (id, agent_id, company_id)
     VALUES ('run-managed', 'agent-managed', 'co-managed')`,
  )
  await pool.query(
    `INSERT INTO user_preferences (user_id, prefs, company_id)
     VALUES ($1, '{"theme":"dark"}'::jsonb, 'personal')`, [TARGET_ID],
  )
  await pool.query(
    `INSERT INTO agent_autonomy (user_id, agent_id, company_id)
     VALUES ($1, 'agent-managed', 'personal')`, [TARGET_ID],
  )
  await pool.query(
    `INSERT INTO llm_calls (id, company_id, agent_id, purpose, model)
     VALUES ('llm-managed', 'co-managed', 'agent-managed', 'agent_turn', 'test-model')`,
  )
  await pool.query(
    `INSERT INTO llm_calls_rollup
       (bucket_hour, company_id, agent_id, purpose, model, source)
     VALUES (date_trunc('hour', NOW()), 'co-managed', 'agent-managed', 'agent_turn', 'test-model', 'cloud')`,
  )
  await pool.query(
    `INSERT INTO boards (id, company_id, title, created_by)
     VALUES ('board-managed', 'co-managed', 'Managed board', $1)`, [OWNER_ID],
  )
  await pool.query(
    `INSERT INTO agent_workspace (agent_id, path, body, company_id)
     VALUES ('agent-managed', 'notes.md', 'workspace content', 'co-managed')`,
  )
  await pool.query(
    `INSERT INTO agent_tasks (id, agent_id, title, company_id)
     VALUES ('task-managed', 'agent-managed', 'test task', 'co-managed')`,
  )
  await pool.query(
    `INSERT INTO agent_climate (agent_id, about_id, company_id, last_note)
     VALUES ('agent-managed', $1, 'co-managed', 'climate note')`,
    [OWNER_ID],
  )
  await pool.query(
    `INSERT INTO agent_log (id, agent_id, kind, body, company_id)
     VALUES ('log-managed', 'agent-managed', 'note', 'log body', 'co-managed')`,
  )

  const runtimeIdentity = await pool.query<{ runtime_assignment_id: string }>(
    `SELECT runtime_assignment_id
       FROM participants
      WHERE id = 'agent-managed' AND company_id = 'co-managed'`,
  )
  assert.ok(runtimeIdentity.rows[0])
  const runtimeClaims = {
    sub: 'agent-managed',
    companyId: 'co-managed',
    computerId: null,
    assignmentId: runtimeIdentity.rows[0].runtime_assignment_id,
  }
  assert.equal(await isRuntimeAgentAuthorized(runtimeClaims), true)

  const response = await fetch(`${ownerBase}/api/companies/co-managed`, {
    method: 'DELETE', headers: companyHeaders('co-managed'),
    body: JSON.stringify({ confirmation: 'Workspace co-managed' }),
  })
  assert.equal(response.status, 200, await response.text())

  for (const [table, predicate] of [
    ['companies', `id = 'co-managed'`],
    ['company_members', `company_id = 'co-managed'`],
    ['participants', `company_id = 'co-managed'`],
    ['conversations', `company_id = 'co-managed'`],
    ['messages', `company_id = 'co-managed'`],
    ['documents', `company_id = 'co-managed'`],
    ['computers', `company_id = 'co-managed'`],
    ['agent_runs', `company_id = 'co-managed'`],
    ['boards', `company_id = 'co-managed'`],
    ['agent_workspace', `company_id = 'co-managed' OR agent_id = 'agent-managed'`],
    ['agent_tasks', `company_id = 'co-managed' OR agent_id = 'agent-managed'`],
    ['agent_climate', `company_id = 'co-managed' OR agent_id = 'agent-managed'`],
    ['agent_log', `company_id = 'co-managed' OR agent_id = 'agent-managed'`],
  ] as const) {
    const remaining = await pool.query(`SELECT 1 FROM ${table} WHERE ${predicate}`)
    assert.equal(remaining.rowCount, 0, `${table} retained workspace rows`)
  }
  const alternative = await pool.query(`SELECT 1 FROM companies WHERE id = 'co-alternative'`)
  assert.equal(alternative.rowCount, 1)
  assert.equal(await isRuntimeAgentAuthorized(runtimeClaims), false)
  assert.equal((await pool.query(`SELECT 1 FROM user_preferences WHERE user_id = $1`, [TARGET_ID])).rowCount, 1)
  assert.equal((await pool.query(`SELECT 1 FROM agent_autonomy WHERE user_id = $1`, [TARGET_ID])).rowCount, 1)
  assert.equal((await pool.query(`SELECT 1 FROM llm_calls WHERE id = 'llm-managed'`)).rowCount, 1)
  assert.equal((await pool.query(`SELECT 1 FROM llm_calls_rollup WHERE company_id = 'co-managed'`)).rowCount, 1)

  const queued = await pool.query<{ id: string; attempts: number; completed_at: Date | null }>(
    `SELECT id, attempts, completed_at FROM workspace_cleanup_jobs WHERE company_id = 'co-managed'`,
  )
  assert.equal(queued.rowCount, 1)
  const failed = await drainWorkspaceCleanupJobs({
    dependencies: { deleteAgentRuntime: async () => { throw new Error('control plane unavailable') } },
  })
  assert.deepEqual(failed, { claimed: 1, completed: 0, failed: 1 })
  const retryable = await pool.query<{ attempts: number; completed_at: Date | null }>(
    `UPDATE workspace_cleanup_jobs SET available_at = NOW()
      WHERE id = $1 RETURNING attempts, completed_at`, [queued.rows[0].id],
  )
  assert.equal(retryable.rows[0].attempts, 1)
  assert.equal(retryable.rows[0].completed_at, null)
  const retried = await drainWorkspaceCleanupJobs({
    dependencies: { deleteAgentRuntime: async () => {} },
  })
  assert.deepEqual(retried, { claimed: 1, completed: 1, failed: 0 })
})