The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.
TypeScript 3d-modelingagent-frameworkagent-harnessai-agentscadclaude-codecodexcoding-agentsdeveloper-toolsesp32game-developmentmcp-servermulti-agentopen-hardwareopencodeopenharnesspcbroboticsterminaltmux
import { randomUUID } from 'node:crypto'
import { execFile } from 'node:child_process'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import { promisify } from 'node:util'
import Fastify, { type FastifyInstance } from 'fastify'
import { PrismaClient } from '@prisma/client'
import { MongoMemoryReplSet } from 'mongodb-memory-server-core'
import { afterAll, beforeAll, describe, expect, it } from 'vitest'
import { NOT_AVAILABLE, superTabRoutes } from '../src/routes/superTabs.js'
import { errorHandler } from '../src/middlewares/errorHandler.js'
import { SuperTabStore } from '../src/superTabs/store.js'
import type { AuthUser } from '../src/lib/ssoAuth.js'
import type { Command } from '../src/superTabs/commands.js'
import { migrateWorkspaces, rollbackWorkspaces } from '../src/superTabs/migration/workspaces.js'
import { hasWorkspaceAccess, SwarmWorkspaces } from '../src/superTabs/workspaceStore.js'
import { plan, profiled, reads } from './plans.test-support.js'
// Workspaces above Swarms (docs/plans/2026-10-27-swarm-workspaces.md): every route, authorization and Mongo transaction is real.
let replica: MongoMemoryReplSet, db: PrismaClient, store: SuperTabStore, app: FastifyInstance
const user = (n: number, email: string): AuthUser => ({ sub: `30000000000000000000000${n}`, email, autonomousEnv: 'prod', role: 'user' })
const owner = user(1, '[email protected]'), peer = user(2, '[email protected]'), other = user(3, '[email protected]'),
admin = user(4, '[email protected]'), member = user(5, '[email protected]')
const legacyOwner = user(6, '[email protected]'), legacyPeer = user(7, '[email protected]')
const returner = user(8, '[email protected]'), newcomer = user(9, '[email protected]')
const accounts = [owner, peer, other, admin, member, legacyOwner, legacyPeer, returner, newcomer]
const call = (method: 'GET' | 'POST', url: string, as: AuthUser, body?: object) =>
app.inject({ method, url, headers: { authorization: `Bearer ${as.sub}` }, ...(body ? { payload: body } : {}) })
const run = async (tab: string, command: Command, as = owner) => {
const reply = await call('POST', `/api/super-tabs/${tab}/commands`, as, { operationId: randomUUID(), command })
if (reply.statusCode !== 200) throw new Error(`${command.type}: ${reply.statusCode} ${reply.body}`)
return reply.json().data as { result: Record<string, unknown> }
}
const create = async (as = owner, name = 'Fixture Swarm', workspaceId?: string) => {
const reply = await call('POST', '/api/super-tabs', as, { operationId: randomUUID(), name, ...(workspaceId ? { workspaceId } : {}) })
if (reply.statusCode !== 200) throw new Error(`create: ${reply.statusCode} ${reply.body}`)
return reply.json().data.id as string
}
const workspacesOf = async (as: AuthUser) => (await call('GET', '/api/super-tabs/workspaces', as)).json().data.workspaces as
Array<{ id: string; name: string; role: string; swarms: Array<{ id: string; name: string; member: boolean }> }>
const listed = async (as: AuthUser) => ((await call('GET', '/api/super-tabs/list', as)).json().data.tabs as Array<{ id: string; workspaceId: string | null }>)
/** Adds `who` to the Swarm the way an owner does today: an invitation, accepted. */
const invite = async (tab: string, who: AuthUser, by = owner) => {
const invitation = await run(tab, { type: 'invite.create', email: who.email, role: 'collaborator', conversationId: 'lead' } as Command, by)
await run(tab, { type: 'invite.accept', inviteId: invitation.result.inviteId as string } as Command, who)
}
beforeAll(async () => {
replica = await MongoMemoryReplSet.create({ binary: { version: '7.0.24', downloadDir: join(tmpdir(), 'harness-super-tab-mongodb-binaries') },
replSet: { count: 1, ip: '127.0.0.1', storageEngine: 'wiredTiger' } })
const uri = replica.getUri(`swarm_workspaces_test_${randomUUID().replaceAll('-', '_')}`)
await promisify(execFile)(join(process.cwd(), 'node_modules/.bin/prisma'), ['db', 'push', '--skip-generate'], {
env: { ...process.env, DATABASE_URL: uri }, timeout: 60000,
})
db = new PrismaClient({ datasources: { db: { url: uri } } })
store = new SuperTabStore(db)
for (const account of accounts) await db.user.create({ data: { id: account.sub, externalId: `workspaces-fixture-${account.sub}`,
email: account.email, autonomousEnv: account.autonomousEnv } })
app = Fastify()
app.setErrorHandler(errorHandler)
app.addHook('onRequest', async (req, reply) => {
const account = accounts.find(a => `Bearer ${a.sub}` === req.headers.authorization)
if (!account) return reply.code(401).send({ success: false })
req.user = account
})
await app.register(superTabRoutes, { store })
await app.ready()
})
afterAll(async () => { await app?.close(); await db?.$disconnect(); await replica?.stop() })
describe('a new Swarm lands in a Workspace', () => {
it('puts a person\'s Swarms in their own Workspace, made on first need, and lists it with its Swarms', async () => {
const first = await create(other, 'Lamp OS'), second = await create(other, 'Second')
const workspaces = await workspacesOf(other)
expect(workspaces).toHaveLength(1)
expect(workspaces[0]).toMatchObject({ name: 'Lamp OS', role: 'owner' })
expect(workspaces[0]!.swarms.map(s => s.id).sort()).toEqual([first, second].sort())
const rows = await listed(other)
expect(rows.filter(r => r.id === first || r.id === second).map(r => r.workspaceId)).toEqual([workspaces[0]!.id, workspaces[0]!.id])
})
})
describe('the Workspace check on every Swarm read and command', () => {
it('refuses a person whose Workspace membership was removed on every read path and command, before their Swarm removal runs', async () => {
const tab = await create(owner, 'Checked')
await invite(tab, peer)
const cursor = (await call('GET', `/api/super-tabs/${tab}/parts`, peer)).json().data.cursor as string
const reads = [`/api/super-tabs/${tab}/parts`, `/api/super-tabs/${tab}/changes?cursor=${encodeURIComponent(cursor)}`, `/api/super-tabs/${tab}/groups?dormant=1`,
`/api/super-tabs/${tab}/groups/lead`, `/api/super-tabs/${tab}/conversations/lead/messages`, `/api/super-tabs/${tab}/mentions?state=waiting`,
`/api/super-tabs/${tab}/decisions?state=open`, `/api/super-tabs/${tab}/route-decisions`, `/api/super-tabs/${tab}/leaderboard?projectId=lead`,
`/api/super-tabs/${tab}/routing-policy`, `/api/super-tabs/${tab}/conversations/lead/attempts`]
for (const url of reads) expect((await call('GET', url, peer)).statusCode, url).toBe(200)
expect((await listed(peer)).map(r => r.id)).toContain(tab)
// As a removal whose Swarm cleanup has not run yet leaves it: the person is still in the Swarm's people.
const [workspace] = await workspacesOf(owner)
const removed = await db.swarmWorkspaceMember.update({ where: { id: `${workspace!.id}:${peer.sub}` }, data: { removedAt: new Date(), removedBy: owner.sub } })
await db.swarmWorkspaceRemoval.create({ data: { id: `${removed.id}:${removed.generation}`, workspaceId: workspace!.id, userId: peer.sub, email: peer.email,
generation: removed.generation, autonomousEnv: 'prod', removedAt: new Date(), removedBy: owner.sub, finishedAt: null } })
// Every Swarm route answers as for a Swarm that does not exist (routes/superTabs.ts NOT_AVAILABLE).
for (const url of reads) {
const reply = await call('GET', url, peer)
expect(reply.statusCode, url).toBe(NOT_AVAILABLE.status)
expect(reply.json().error.code, url).toBe(NOT_AVAILABLE.code)
}
const send = await call('POST', `/api/super-tabs/${tab}/commands`, peer,
{ operationId: randomUUID(), command: { type: 'message.send', conversationId: 'lead', text: 'still here?', replyTo: null, recipientIds: [] } })
expect(send.statusCode).toBe(NOT_AVAILABLE.status)
expect((await listed(peer)).map(r => r.id)).not.toContain(tab)
// The Swarm's own people are untouched.
expect((await call('GET', `/api/super-tabs/${tab}/parts`, owner)).statusCode).toBe(200)
// The sweep finishes the Swarm removal that did not run.
expect(await swarmPeople(tab)).toContain(peer.sub)
expect(await store.workspaces.finishRemovals()).toBe(0)
expect(await swarmPeople(tab)).not.toContain(peer.sub)
})
it('keeps a person of one Workspace out of another Workspace\'s Swarm', async () => {
const theirs = await create(other, 'Elsewhere')
const reply = await call('GET', `/api/super-tabs/${theirs}/parts`, owner)
expect(reply.json().error).toEqual({ code: NOT_AVAILABLE.code, message: NOT_AVAILABLE.message })
expect(JSON.stringify(reply.json())).not.toContain('Elsewhere')
expect((await workspacesOf(owner)).flatMap(o => o.swarms.map(s => s.id))).not.toContain(theirs)
})
})
/** A Workspace of the owner with an admin, a member and a guest, each having accepted their invitation. */
async function workspace(name: string) {
const created = await call('POST', '/api/super-tabs/workspaces', owner, { operationId: randomUUID(), name })
if (created.statusCode !== 200) throw new Error(`workspace create: ${created.statusCode} ${created.body}`)
const workspaceId = created.json().data.id as string
for (const [who, role] of [[admin, 'admin'], [member, 'member'], [peer, 'guest']] as const) {
const invited = await call('POST', `/api/super-tabs/workspaces/${workspaceId}/invitations`, owner, { email: who.email, role })
if (invited.statusCode !== 200) throw new Error(`invite: ${invited.statusCode} ${invited.body}`)
const accepted = await call('POST', `/api/super-tabs/workspaces/${workspaceId}/accept`, who, {})
if (accepted.statusCode !== 200) throw new Error(`accept: ${accepted.statusCode} ${accepted.body}`)
}
return workspaceId
}
const people = async (workspaceId: string, as: AuthUser) => call('GET', `/api/super-tabs/workspaces/${workspaceId}/members`, as)
const roleOf = async (workspaceId: string, who: AuthUser) =>
((await people(workspaceId, owner)).json().data.members as Array<{ userId: string; role: string }>).find(m => m.userId === who.sub)?.role
const swarmPeople = async (tab: string) => ((await call('GET', `/api/super-tabs/${tab}/parts`, owner)).json().data.members as Array<{ data: { id: string } }>).map(p => p.data.id)
describe('Workspace people and roles', () => {
it('shows the people list to members and up, never to guests or outsiders, and lets only owners and admins invite', async () => {
const workspaceId = await workspace('People')
const list = await people(workspaceId, member)
expect(list.statusCode).toBe(200)
expect((list.json().data.members as Array<{ email: string; role: string }>).map(m => [m.email, m.role]).sort()).toEqual([
[admin.email, 'admin'], [member.email, 'member'], [owner.email, 'owner'], [peer.email, 'guest']].sort())
expect((await people(workspaceId, peer)).statusCode).toBe(403)
expect((await people(workspaceId, other)).statusCode).toBe(404)
// Someone not invited cannot accept.
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/accept`, other, {})).statusCode).toBe(404)
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/invitations`, member, { email: other.email, role: 'guest' })).statusCode).toBe(403)
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/invitations`, admin, { email: other.email, role: 'admin' })).statusCode).toBe(403)
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/invitations`, admin, { email: other.email, role: 'guest' })).statusCode).toBe(200)
})
it('lets an admin change members and guests but not another admin, and the owner anyone but themselves', async () => {
const workspaceId = await workspace('Roles')
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/members/${peer.sub}`, admin, { role: 'member' })).statusCode).toBe(200)
expect(await roleOf(workspaceId, peer)).toBe('member')
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/members/${admin.sub}`, admin, { role: 'member' })).statusCode).toBe(403)
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/members/${member.sub}`, admin, { role: 'admin' })).statusCode).toBe(403)
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/members/${admin.sub}`, owner, { role: 'member' })).statusCode).toBe(200)
expect(await roleOf(workspaceId, admin)).toBe('member')
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/members/${owner.sub}`, owner, { role: 'admin' })).statusCode).toBe(403)
})
it('transfers ownership only to an admin; the old owner becomes an admin', async () => {
const workspaceId = await workspace('Transfer')
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/transfer`, owner, { userId: member.sub })).statusCode).toBe(409)
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/transfer`, admin, { userId: admin.sub })).statusCode).toBe(403)
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/transfer`, owner, { userId: admin.sub })).statusCode).toBe(200)
expect([await roleOf(workspaceId, admin), await roleOf(workspaceId, owner)]).toEqual(['owner', 'admin'])
})
})
describe('Swarms open to the Workspace', () => {
it('lets members, not guests, find and join a Swarm only once it is open to the Workspace', async () => {
const workspaceId = await workspace('Open')
const tab = await create(owner, 'Shared work', workspaceId)
const names = async (who: AuthUser) => (await workspacesOf(who)).find(o => o.id === workspaceId)?.swarms.map(s => s.id) ?? []
expect(await names(member)).not.toContain(tab)
expect(await names(admin)).toContain(tab)
// Not open to them yet, and not theirs to open: refused as a Swarm that does not exist, as their Workspace list says.
expect((await call('POST', `/api/super-tabs/${tab}/workspace-join`, member, { operationId: randomUUID() })).statusCode).toBe(NOT_AVAILABLE.status)
expect((await call('POST', `/api/super-tabs/${tab}/workspace-visibility`, member, { visibility: 'workspace' })).statusCode).toBe(NOT_AVAILABLE.status)
expect((await call('POST', `/api/super-tabs/${tab}/workspace-visibility`, owner, { visibility: 'workspace' })).statusCode).toBe(200)
expect(await names(member)).toContain(tab)
const joinedOf = async (who: AuthUser) => (await workspacesOf(who)).find(o => o.id === workspaceId)!.swarms.find(s => s.id === tab)!.member
expect([await joinedOf(member), await joinedOf(owner)]).toEqual([false, true])
expect(await names(peer)).not.toContain(tab)
// A guest is never shown it, and is refused it as a Swarm that does not exist.
expect((await call('POST', `/api/super-tabs/${tab}/workspace-join`, peer, { operationId: randomUUID() })).statusCode).toBe(NOT_AVAILABLE.status)
const joined = await call('POST', `/api/super-tabs/${tab}/workspace-join`, member, { operationId: randomUUID() })
expect(joined.statusCode).toBe(200)
expect(joined.json().data.role).toBe('collaborator')
expect((await call('GET', `/api/super-tabs/${tab}/parts`, member)).statusCode).toBe(200)
// Closing it again leaves those who joined, and hides it from the others.
expect((await call('POST', `/api/super-tabs/${tab}/workspace-visibility`, admin, { visibility: 'invite-only' })).statusCode).toBe(200)
expect((await call('GET', `/api/super-tabs/${tab}/parts`, member)).statusCode).toBe(200)
})
it('refuses creating a Swarm in a Workspace for a guest or an outsider', async () => {
const workspaceId = await workspace('Create')
for (const who of [peer, other]) {
const reply = await call('POST', '/api/super-tabs', who, { operationId: randomUUID(), name: 'Mine', workspaceId })
expect(reply.statusCode, who.email).not.toBe(200)
}
})
})
describe('removing someone from a Workspace', () => {
it('removes them from every Swarm of the Workspace at once, and leaves their other Workspaces alone', async () => {
const workspaceId = await workspace('Removal')
const a = await create(owner, 'A', workspaceId), b = await create(owner, 'B', workspaceId)
for (const tab of [a, b]) await invite(tab, member)
const elsewhere = await create(other, 'Their own')
await invite(elsewhere, member, other)
const removed = await call('POST', `/api/super-tabs/workspaces/${workspaceId}/members/${member.sub}/remove`, admin, {})
expect(removed.statusCode).toBe(200)
for (const tab of [a, b]) {
expect(await swarmPeople(tab)).not.toContain(member.sub)
expect((await call('GET', `/api/super-tabs/${tab}/parts`, member)).statusCode).toBe(NOT_AVAILABLE.status)
}
expect((await workspacesOf(member)).map(o => o.id)).not.toContain(workspaceId)
expect((await call('GET', `/api/super-tabs/${elsewhere}/parts`, member)).statusCode).toBe(200)
})
it('never removes the owner, nor someone who owns one of the Workspace\'s Swarms, and lets a person leave by themselves', async () => {
const workspaceId = await workspace('Guards')
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/members/${owner.sub}/remove`, owner, {})).statusCode).toBe(409)
await create(member, 'Member owned', workspaceId)
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/members/${member.sub}/remove`, owner, {})).statusCode).toBe(409)
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/members/${peer.sub}/remove`, peer, {})).statusCode).toBe(200)
expect((await workspacesOf(peer)).map(o => o.id)).not.toContain(workspaceId)
})
it('keeps a removed person from rejoining by a link, while a new invitation brings them back', async () => {
const workspaceId = await workspace('Rejoin')
const tab = await create(owner, 'Linked', workspaceId)
const sharing = await store.sharing(owner, tab)
const saved = await store.saveSharing(owner, tab, { operationId: randomUUID(), revision: sharing.revision, access: { mode: 'link', role: 'collaborator' } })
const token = new URL(saved.joinUrl!).searchParams.get('token')!
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/members/${peer.sub}/remove`, owner, {})).statusCode).toBe(200)
const again = await call('POST', `/api/super-tabs/${tab}/join`, peer, { operationId: randomUUID(), token })
expect(again.json().error).toEqual({ code: NOT_AVAILABLE.code, message: NOT_AVAILABLE.message })
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/invitations`, owner, { email: peer.email, role: 'guest' })).statusCode).toBe(200)
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/accept`, peer, {})).statusCode).toBe(200)
expect((await call('POST', `/api/super-tabs/${tab}/join`, peer, { operationId: randomUUID(), token })).statusCode).toBe(200)
})
it('withdraws their pending invitation, so accepting it afterwards finds none and they stay removed', async () => {
const workspaceId = await workspace('Final')
// Sent before the removal, and never accepted: today it would bring them back as an admin.
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/invitations`, owner, { email: member.email, role: 'admin' })).statusCode).toBe(200)
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/members/${member.sub}/remove`, owner, {})).statusCode).toBe(200)
expect(await db.swarmWorkspaceInvitation.findUnique({ where: { id: `${workspaceId}:${member.email}` } })).toBeNull()
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/accept`, member, {})).statusCode).toBe(404)
expect((await db.swarmWorkspaceMember.findUniqueOrThrow({ where: { id: `${workspaceId}:${member.sub}` } })).removedAt).not.toBeNull()
expect((await workspacesOf(member)).map(o => o.id)).not.toContain(workspaceId)
})
it('refuses an invitation sent before their latest removal, and accepts one sent after it', async () => {
const workspaceId = await workspace('Stale')
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/members/${member.sub}/remove`, owner, {})).statusCode).toBe(200)
// As a removal before this fix left it: an admin invitation sent a minute before the removal, still pending.
const removal = await db.swarmWorkspaceRemoval.findFirstOrThrow({ where: { workspaceId, userId: member.sub } })
const sentAt = removal.removedAt.getTime() - 60_000
await db.swarmWorkspaceInvitation.create({ data: { id: `${workspaceId}:${member.email}`, workspaceId, email: member.email, role: 'admin',
invitedBy: owner.sub, expiresAt: new Date(sentAt + 14 * 24 * 60 * 60 * 1000) } })
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/accept`, member, {})).statusCode).toBe(404)
expect((await db.swarmWorkspaceMember.findUniqueOrThrow({ where: { id: `${workspaceId}:${member.sub}` } })).removedAt).not.toBeNull()
// A new invitation, sent after the removal, brings them back with its role.
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/invitations`, owner, { email: member.email, role: 'guest' })).statusCode).toBe(200)
const accepted = await call('POST', `/api/super-tabs/workspaces/${workspaceId}/accept`, member, {})
expect(accepted.statusCode).toBe(200)
expect(accepted.json().data.role).toBe('guest')
})
it('reads only the accepting person\'s removals, by the Workspace and person index', async () => {
const workspaceId = await workspace('Removal reads')
for (const who of [peer, member]) expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/members/${who.sub}/remove`, owner, {})).statusCode).toBe(200)
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/invitations`, owner, { email: member.email, role: 'guest' })).statusCode).toBe(200)
const entries = await profiled(db, async () => expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/accept`, member, {})).statusCode).toBe(200))
// The read of the newest removal; finishPending's read of open ones names finishedAt.
const rows = reads(entries, 'SwarmWorkspaceRemoval', ['workspaceId', 'userId'], ['finishedAt'])
expect(rows, JSON.stringify(plan(rows))).toHaveLength(1)
expect(rows[0]!.planSummary, JSON.stringify(plan(rows))).toMatch(/IXSCAN \{ workspaceId: 1, userId: 1, finishedAt: 1/)
expect(rows[0]!.docsExamined, JSON.stringify(plan(rows))).toBe(1)
})
it('accepts an invitation for someone never removed as today', async () => {
const workspaceId = await workspace('Never removed')
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/invitations`, admin, { email: newcomer.email, role: 'member' })).statusCode).toBe(200)
const accepted = await call('POST', `/api/super-tabs/workspaces/${workspaceId}/accept`, newcomer, {})
expect(accepted.statusCode).toBe(200)
expect(accepted.json().data).toEqual({ workspaceId, role: 'member' })
expect(await roleOf(workspaceId, newcomer)).toBe('member')
})
})
describe('revoking a pending Workspace invitation', () => {
const revoke = (workspaceId: string, as: AuthUser, email: string) => call('POST', `/api/super-tabs/workspaces/${workspaceId}/invitations/revoke`, as, { email })
const pending = async (workspaceId: string) =>
((await people(workspaceId, owner)).json().data.invitations as Array<{ email: string; role: string }>).map(i => i.email)
it('lets owners and admins revoke invitations for roles they may give, after which accepting finds none', async () => {
const workspaceId = await workspace('Revoke')
for (const [email, role] of [[other.email, 'admin'], [newcomer.email, 'guest']] as const) {
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/invitations`, owner, { email, role })).statusCode).toBe(200)
}
// A member, a guest and an outsider cannot; an admin cannot withdraw an admin invitation it could not have sent.
expect((await revoke(workspaceId, member, other.email)).statusCode).toBe(403)
expect((await revoke(workspaceId, peer, other.email)).statusCode).toBe(403)
expect((await revoke(workspaceId, returner, other.email)).statusCode).toBe(404)
expect((await revoke(workspaceId, admin, other.email)).statusCode).toBe(403)
expect((await pending(workspaceId)).sort()).toEqual([newcomer.email, other.email].sort())
expect((await revoke(workspaceId, admin, newcomer.email)).statusCode).toBe(200)
const revoked = await revoke(workspaceId, owner, other.email.toUpperCase())
expect(revoked.statusCode).toBe(200)
expect(revoked.json().data).toEqual({ email: other.email, revoked: true })
expect(await pending(workspaceId)).toEqual([])
expect(await db.swarmWorkspaceInvitation.count({ where: { workspaceId } })).toBe(0)
for (const who of [other, newcomer]) expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/accept`, who, {})).statusCode).toBe(404)
// Nothing left to revoke.
expect((await revoke(workspaceId, owner, other.email)).statusCode).toBe(404)
})
})
describe('a machine contributed to Swarms of two Workspaces', () => {
/** A contributed machine as the Swarm's parts hold it (only the fields this lookup reads). */
const contribute = (tabId: string, machineId: string) => db.swarmMachine.create({ data: { id: `${tabId}:machine:${machineId}`, tabId,
key: machineId, version: 1, changedAt: new Date(), ordinal: 0, data: {}, machineId, contributed: true, cleanupOwnerIds: [] } })
const lookup = async (tabId: string, machineId: string) => db.$transaction(async tx => {
const state = { ...(await store.load(tx, owner, tabId)).state }
return store.otherWorkspaceMachines(tx, { ...state, machines: [{ machineId } as never] })
})
it('is named for this Swarm only when the other Swarm is in another Workspace', async () => {
const workspaceId = await workspace('Machines')
const here = await create(owner, 'Here', workspaceId), sameWorkspace = await create(owner, 'Same Workspace', workspaceId), elsewhere = await create(other, 'Other Workspace')
await contribute(sameWorkspace, 'shared-mac')
expect(await lookup(here, 'shared-mac')).toEqual([])
await contribute(elsewhere, 'shared-mac')
expect(await lookup(here, 'shared-mac')).toEqual(['shared-mac'])
})
})
describe('the migration of today\'s Swarms into Workspaces, and its undo', () => {
/** A Swarm as it was before Workspaces: no Workspace on its row or head, and no Workspace of its owner. */
async function legacy(as: AuthUser, name: string) {
const tab = await create(as, name)
const head = await db.swarmHead.findUniqueOrThrow({ where: { id: `${tab}:head` } })
const { workspaceId: _workspaceId, ...data } = head.data as Record<string, unknown>
await db.swarmHead.update({ where: { id: head.id }, data: { data: data as never } })
await db.superTab.update({ where: { id: tab }, data: { workspaceId: null } })
await db.swarmWorkspaceMember.deleteMany({ where: { userId: as.sub } })
await db.swarmWorkspace.deleteMany({ where: { ownerId: as.sub } })
return tab
}
it('dry-runs without writing, then puts each owner\'s Swarms in one Workspace with everyone else a guest, once; the undo restores today', async () => {
const first = await legacy(legacyOwner, 'Legacy one'), second = await legacy(legacyOwner, 'Legacy two')
await invite(first, legacyPeer, legacyOwner)
const before = await call('GET', `/api/super-tabs/${second}/parts`, legacyOwner)
const dry = await migrateWorkspaces(db, { apply: false })
expect(dry.swarms).toBe(2)
expect(dry.workspacesCreated).toBe(1)
expect(await db.superTab.count({ where: { id: { in: [first, second] }, workspaceId: { not: null } } })).toBe(0)
expect(await db.swarmWorkspace.count({ where: { ownerId: legacyOwner.sub } })).toBe(0)
const applied = await migrateWorkspaces(db, { apply: true })
expect(applied).toMatchObject({ swarms: 2, workspacesCreated: 1, guestsAdded: 1, failed: [] })
const [ownerWorkspace] = await workspacesOf(legacyOwner)
expect(ownerWorkspace).toMatchObject({ name: 'Legacy one', role: 'owner' })
expect(ownerWorkspace!.swarms.map(s => s.id).sort()).toEqual([first, second].sort())
const peerWorkspaces = await workspacesOf(legacyPeer)
expect(peerWorkspaces.map(o => [o.id, o.role, o.swarms.map(s => s.id)])).toEqual([[ownerWorkspace!.id, 'guest', [first]]])
// Nobody gains or loses access.
expect((await call('GET', `/api/super-tabs/${first}/parts`, legacyPeer)).statusCode).toBe(200)
expect((await call('GET', `/api/super-tabs/${second}/parts`, legacyPeer)).statusCode).toBe(NOT_AVAILABLE.status)
expect((await call('GET', `/api/super-tabs/${second}/parts`, legacyOwner)).json().data.members).toEqual(before.json().data.members)
expect((await call('GET', `/api/super-tabs/${second}/parts`, legacyOwner)).json().data.head.data.workspaceId).toBe(ownerWorkspace!.id)
expect(await migrateWorkspaces(db, { apply: true })).toMatchObject({ swarms: 0, workspacesCreated: 0, guestsAdded: 0 })
const undone = await rollbackWorkspaces(db, { apply: true })
expect(undone.failed).toEqual([])
expect(await db.superTab.count({ where: { id: { in: [first, second] }, workspaceId: { not: null } } })).toBe(0)
expect((await call('GET', `/api/super-tabs/${second}/parts`, legacyOwner)).json().data.head.data.workspaceId).toBeUndefined()
expect(await db.swarmWorkspaceMember.count({ where: { userId: { in: [legacyOwner.sub, legacyPeer.sub] } } })).toBe(0)
expect((await call('GET', `/api/super-tabs/${first}/parts`, legacyPeer)).statusCode).toBe(200)
})
it('serves a Swarm without a Workspace by its own membership until the switch is on, then refuses and stops listing it', async () => {
const tab = await legacy(legacyOwner, 'Before Workspaces')
expect((await call('GET', `/api/super-tabs/${tab}/parts`, legacyOwner)).statusCode).toBe(200)
process.env.SWARM_WORKSPACES_REQUIRED = '1'
try {
const reply = await call('GET', `/api/super-tabs/${tab}/parts`, legacyOwner)
expect(reply.statusCode).toBe(NOT_AVAILABLE.status)
expect(reply.json().error.code).toBe(NOT_AVAILABLE.code)
expect((await listed(legacyOwner)).map(r => r.id)).not.toContain(tab)
} finally { delete process.env.SWARM_WORKSPACES_REQUIRED }
await migrateWorkspaces(db, { apply: true })
await rollbackWorkspaces(db, { apply: true })
})
it('lists the machines that would serve two Workspaces afterwards, before anything is written', async () => {
const mine = await legacy(legacyOwner, 'Mine'), theirs = await legacy(legacyPeer, 'Theirs')
for (const tabId of [mine, theirs]) await db.swarmMachine.create({ data: { id: `${tabId}:machine:both`, tabId, key: 'both-mac', version: 1,
changedAt: new Date(), ordinal: 0, data: {}, machineId: 'both-mac', contributed: true, cleanupOwnerIds: [] } })
const dry = await migrateWorkspaces(db, { apply: false })
expect(dry.anomalies.machinesInTwoWorkspaces).toContainEqual({ machineId: 'both-mac', tabIds: [mine, theirs].sort() })
await migrateWorkspaces(db, { apply: true })
await rollbackWorkspaces(db, { apply: true })
})
})
describe('what the Workspace check costs', () => {
it('reads one small Workspace row per person per request, once however many agents that person contributed', async () => {
let reads = 0
const counted = db.$extends({ query: { swarmWorkspaceMember: { async findUnique({ args, query }) { reads++; return query(args) } } } }) as unknown as PrismaClient
const counting = new SuperTabStore(counted)
const tab = await create(owner, 'Counted')
reads = 0
await counting.read(owner, tab)
expect(reads).toBe(1)
reads = 0
await counted.$transaction(async tx => {
const { state } = await counting.load(tx, owner, tab)
for (let i = 0; i < 5; i++) expect(await hasWorkspaceAccess(tx, state, owner.sub)).toBe(true)
})
expect(reads).toBe(1)
})
})
describe('a removal whose Swarm cleanup failed', () => {
/** As a removal leaves things when leaving one Swarm failed: removed from the Workspace, its record open, still in the Swarm. */
async function failedRemoval(workspaceId: string, who: AuthUser) {
const row = await db.swarmWorkspaceMember.findUniqueOrThrow({ where: { id: `${workspaceId}:${who.sub}` } })
await db.swarmWorkspaceMember.update({ where: { id: row.id }, data: { removedAt: new Date(), removedBy: owner.sub } })
await db.swarmWorkspaceRemoval.create({ data: { id: `${row.id}:${row.generation}`, workspaceId, userId: who.sub, email: who.email,
generation: row.generation, autonomousEnv: 'prod', removedAt: new Date(), removedBy: owner.sub, finishedAt: null } })
}
it('is finished before a Workspace-only re-invite brings the person back, so the old private Swarm stays closed to them', async () => {
const workspaceId = await workspace('Revival')
const privateTab = await create(owner, 'Private work', workspaceId)
await invite(privateTab, member)
const operationId = randomUUID(), command = { type: 'message.send', conversationId: 'lead', text: 'before', replyTo: null, recipientIds: [] }
expect((await call('POST', `/api/super-tabs/${privateTab}/commands`, member, { operationId, command })).statusCode).toBe(200)
await failedRemoval(workspaceId, member)
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/invitations`, owner, { email: member.email, role: 'member' })).statusCode).toBe(200)
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/accept`, member, {})).statusCode).toBe(200)
expect((await workspacesOf(member)).map(o => o.id)).toContain(workspaceId)
expect(await swarmPeople(privateTab)).not.toContain(member.sub)
expect((await call('GET', `/api/super-tabs/${privateTab}/parts`, member)).statusCode).toBe(NOT_AVAILABLE.status)
expect((await call('POST', `/api/super-tabs/${privateTab}/commands`, member, { operationId, command })).statusCode).toBe(NOT_AVAILABLE.status)
})
it('keeps the person out while the earlier removal cannot finish', async () => {
const workspaceId = await workspace('Stuck')
const tab = await create(owner, 'Stuck work', workspaceId), elsewhere = await create(owner, 'Healthy work', workspaceId)
await invite(tab, member)
await failedRemoval(workspaceId, member)
// The Swarm cannot be loaded for now, so leaving it fails again.
await db.superTab.update({ where: { id: tab }, data: { format: 1 } })
try {
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/invitations`, owner, { email: member.email, role: 'member' })).statusCode).toBe(200)
const accepted = await call('POST', `/api/super-tabs/workspaces/${workspaceId}/accept`, member, {})
expect(accepted.statusCode).toBe(409)
expect((await workspacesOf(member)).map(o => o.id)).not.toContain(workspaceId)
// Nor does a Swarm invitation make them a guest of the Workspace meanwhile.
const invitation = await run(elsewhere, { type: 'invite.create', email: member.email, role: 'collaborator', conversationId: 'lead' } as Command)
const viaSwarm = await call('POST', `/api/super-tabs/${elsewhere}/commands`, member,
{ operationId: randomUUID(), command: { type: 'invite.accept', inviteId: invitation.result.inviteId } })
expect(viaSwarm.statusCode).toBe(409)
} finally { await db.superTab.update({ where: { id: tab }, data: { format: 2 } }) }
})
})
describe('the sweep of unfinished removals', () => {
it('reaches every open removal, however many, including one whose first try failed', async () => {
const workspaceId = await workspace('Many removals')
const tab = await create(owner, 'Last one', workspaceId)
await invite(tab, member)
const removedAt = new Date(Date.now() - 60_000)
await db.swarmWorkspaceRemoval.createMany({ data: Array.from({ length: 500 }, (_, i) => ({ id: `${workspaceId}:filler-${i}:g`, workspaceId,
userId: `filler-${i}`, email: `filler-${i}@example.com`, generation: 'g', autonomousEnv: 'prod', removedAt, removedBy: owner.sub, finishedAt: null })) })
const row = await db.swarmWorkspaceMember.findUniqueOrThrow({ where: { id: `${workspaceId}:${member.sub}` } })
await db.swarmWorkspaceMember.update({ where: { id: row.id }, data: { removedAt: new Date() } })
await db.swarmWorkspaceRemoval.create({ data: { id: `${row.id}:${row.generation}`, workspaceId, userId: member.sub, email: member.email,
generation: row.generation, autonomousEnv: 'prod', removedAt: new Date(), removedBy: owner.sub, finishedAt: null } })
let failOnce = true
const leaves: string[] = []
const workspaces = new SwarmWorkspaces(db, { transaction: body => db.$transaction(body), now: Date.now, leave: async (person, tabId, operationId) => {
if (tabId !== tab) return store.workspaces['deps'].leave(person, tabId, operationId)
leaves.push(`${person.sub}:${tabId}`)
if (failOnce) { failOnce = false; throw new Error('the Swarm was busy') }
return store.workspaces['deps'].leave(person, tabId, operationId)
} })
expect(await workspaces.finishRemovals()).toBeGreaterThanOrEqual(1)
expect(await workspaces.finishRemovals()).toBe(0)
expect(leaves).toEqual([`${member.sub}:${tab}`, `${member.sub}:${tab}`])
expect(await swarmPeople(tab)).not.toContain(member.sub)
expect(await db.swarmWorkspaceRemoval.count({ where: { workspaceId, finishedAt: null } })).toBe(0)
})
})
describe('who may invite people to a Workspace\'s Swarm', () => {
it('lets the Swarm\'s owner and the Workspace\'s owners, admins and members in it invite, never a guest; revoking is for owners and admins', async () => {
const workspaceId = await workspace('Inviting')
const tab = await create(owner, 'Invites', workspaceId)
for (const who of [admin, member, peer]) await invite(tab, who)
const inviteAs = async (who: AuthUser, email: string) => call('POST', `/api/super-tabs/${tab}/commands`, who,
{ operationId: randomUUID(), command: { type: 'invite.create', email, role: 'collaborator', conversationId: 'lead' } })
for (const [who, email] of [[owner, '[email protected]'], [admin, '[email protected]'], [member, '[email protected]']] as const) {
const reply = await inviteAs(who, email)
expect(reply.statusCode, who.email).toBe(200)
}
const refused = await inviteAs(peer, '[email protected]')
expect(refused.statusCode).toBe(403)
const inviteId = (await inviteAs(member, '[email protected]')).json().data.result.inviteId as string
const revokeAs = (who: AuthUser) => call('POST', `/api/super-tabs/${tab}/commands`, who,
{ operationId: randomUUID(), command: { type: 'invite.revoke', inviteId } })
expect((await revokeAs(member)).statusCode).toBe(403)
expect((await revokeAs(admin)).statusCode).toBe(200)
})
})
describe('a Swarm invitation for someone the Workspace removed', () => {
/** A Workspace with `returner` in it as a member, and a Swarm of it that the plain member is in. */
const setUp = async (name: string) => {
const workspaceId = await workspace(name)
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/invitations`, owner, { email: returner.email, role: 'member' })).statusCode).toBe(200)
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/accept`, returner, {})).statusCode).toBe(200)
const tab = await create(owner, `${name} work`, workspaceId)
await invite(tab, member)
await invite(tab, admin)
return { workspaceId, tab }
}
const removeReturner = async (workspaceId: string) =>
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/members/${returner.sub}/remove`, admin, {})).statusCode).toBe(200)
const inviteAs = (tab: string, by: AuthUser, email = returner.email) => call('POST', `/api/super-tabs/${tab}/commands`, by,
{ operationId: randomUUID(), command: { type: 'invite.create', email, role: 'collaborator', conversationId: 'lead' } })
const accept = (tab: string, inviteId: string, who = returner) => store.execute(who, tab, { operationId: randomUUID(), command: { type: 'invite.accept', inviteId } as Command })
const rowOf = (workspaceId: string, who: AuthUser) => db.swarmWorkspaceMember.findUniqueOrThrow({ where: { id: `${workspaceId}:${who.sub}` } })
const declined = async (workspaceId: string) => (await db.swarmWorkspace.findUniqueOrThrow({ where: { id: workspaceId } })).autoJoinDeclined
const keptOut = async (workspaceId: string, tab: string) => {
expect((await rowOf(workspaceId, returner)).removedAt).not.toBeNull()
expect(await declined(workspaceId)).toContain(returner.sub)
expect(await swarmPeople(tab)).not.toContain(returner.sub)
}
it('refuses a plain member\'s invitation, at create and at accept, and keeps the removal and the decline', async () => {
const { workspaceId, tab } = await setUp('Undo removal')
// Sent while they were still in the Workspace, and by an admin who is a member by the time it is accepted.
const early = (await inviteAs(tab, member)).json().data.result.inviteId as string
await removeReturner(workspaceId)
const created = await inviteAs(tab, member)
expect(created.statusCode).toBe(403)
expect(created.json().error.code).toBe('WORKSPACE_ROLE_REQUIRED')
await keptOut(workspaceId, tab)
await expect(accept(tab, early)).rejects.toMatchObject({ code: 'WORKSPACE_ACCESS_REVOKED', status: 403 })
const overRoute = await call('POST', `/api/super-tabs/${tab}/commands`, returner, { operationId: randomUUID(), command: { type: 'invite.accept', inviteId: early } })
expect(overRoute.statusCode).toBe(NOT_AVAILABLE.status)
await keptOut(workspaceId, tab)
const byAdmin = (await inviteAs(tab, admin)).json().data.result.inviteId as string
expect((await call('POST', `/api/super-tabs/workspaces/${workspaceId}/members/${admin.sub}`, owner, { role: 'member' })).statusCode).toBe(200)
await expect(accept(tab, byAdmin)).rejects.toMatchObject({ code: 'WORKSPACE_ACCESS_REVOKED' })
await keptOut(workspaceId, tab)
})
it('brings them back on a Workspace admin\'s invitation, with the admin as addedBy', async () => {
const { workspaceId, tab } = await setUp('Admin brings back')
await removeReturner(workspaceId)
const created = await inviteAs(tab, admin)
expect(created.statusCode).toBe(200)
await accept(tab, created.json().data.result.inviteId as string)
const row = await rowOf(workspaceId, returner)
expect(row).toMatchObject({ removedAt: null, role: 'guest', addedBy: admin.sub })
expect(await declined(workspaceId)).not.toContain(returner.sub)
expect(await swarmPeople(tab)).toContain(returner.sub)
})
it('refuses even an admin\'s invitation sent before the removal, while one sent after it brings them back (#3173)', async () => {
const { workspaceId, tab } = await setUp('Sent before removal')
// Sent while they were in the Workspace and not yet in this Swarm; the removal leaves only Swarms they are in.
const early = (await inviteAs(tab, admin)).json().data.result.inviteId as string
await removeReturner(workspaceId)
await expect(accept(tab, early)).rejects.toMatchObject({ code: 'WORKSPACE_ACCESS_REVOKED', status: 403 })
await keptOut(workspaceId, tab)
const again = await inviteAs(tab, admin)
expect(again.statusCode).toBe(200)
await accept(tab, again.json().data.result.inviteId as string)
expect(await rowOf(workspaceId, returner)).toMatchObject({ removedAt: null, role: 'guest', addedBy: admin.sub })
expect(await swarmPeople(tab)).toContain(returner.sub)
})
it('lets a person never removed join through a member\'s invitation as today, credited to that member', async () => {
const { workspaceId, tab } = await setUp('Never removed')
const created = await inviteAs(tab, member, newcomer.email)
expect(created.statusCode).toBe(200)
await accept(tab, created.json().data.result.inviteId as string, newcomer)
expect(await rowOf(workspaceId, newcomer)).toMatchObject({ removedAt: null, role: 'guest', addedBy: member.sub })
expect(await swarmPeople(tab)).toContain(newcomer.sub)
})
})