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

feat(workspace): add member and deletion management (#147)

LILACddbbfed31ec2
diff --git a/.env.example b/.env.example
index 33b0a10..a32054d 100644
--- a/.env.example
+++ b/.env.example
@@ -22,6 +22,11 @@ NODE_ENV=development
# delays realtime refresh; clients reconcile from the API on reload.
# REDIS_URL=redis://localhost:6379
+# Durable cleanup jobs created by workspace deletion. Storage cleanup is
+# always safe to run; Kubernetes Pod/PVC cleanup requires an explicit opt-in.
+# WORKSPACE_CLEANUP_INTERVAL_MS=60000
+# WORKSPACE_RUNTIME_CLEANUP_ENABLED=false
+
# ─── OpenAI (required) ────────────────────────────────────────────────────
# Used for agent chat turns, classifier, and image generation.
OPENAI_API_KEY=sk-...
diff --git a/server/k8s/cumora-server.gke.yaml b/server/k8s/cumora-server.gke.yaml
index 6425720..2cd47c0 100644
--- a/server/k8s/cumora-server.gke.yaml
+++ b/server/k8s/cumora-server.gke.yaml
@@ -146,6 +146,8 @@ spec:
# reachable from the cluster (and pull-secret-able if private).
- name: CUMORA_AGENT_COMPUTER_IMAGE
value: "quay.io/yetoneful/cumora-agent-computer:REPLACE-TAG"
+ - name: WORKSPACE_RUNTIME_CLEANUP_ENABLED
+ value: "true"
# Pull secrets the orchestrator attaches to each agent Pod
# spec. Comma-separated. Must exist in CUMORA_AGENT_NAMESPACE.
- name: CUMORA_AGENT_PULL_SECRETS
diff --git a/server/k8s/cumora-server.orbstack.yaml b/server/k8s/cumora-server.orbstack.yaml
index d9039c3..37e2be0 100644
--- a/server/k8s/cumora-server.orbstack.yaml
+++ b/server/k8s/cumora-server.orbstack.yaml
@@ -88,6 +88,8 @@ spec:
value: "http://cumora-server.default.svc.cluster.local:5181/runtime"
- name: CUMORA_AGENT_NAMESPACE
value: "default"
+ - name: WORKSPACE_RUNTIME_CLEANUP_ENABLED
+ value: "true"
# In-cluster PG is also reachable via the service URL above
# for the agent FUSE driver's HTTP traffic; PG itself lives
# on the host in dev (host.docker.internal:5432, set in the
diff --git a/server/src/__integration__/_helpers.ts b/server/src/__integration__/_helpers.ts
index 3ea48cf..784124e 100644
--- a/server/src/__integration__/_helpers.ts
+++ b/server/src/__integration__/_helpers.ts
@@ -14,8 +14,8 @@
* subsume).
*/
import { createHmac, randomUUID } from 'node:crypto'
-import { pool } from '../db/pool.js'
import { ensureSchema } from '../db/migrate.js'
+import { pool } from '../db/pool.js'
import { env } from '../env.js'
let schemaReady: Promise<void> | null = null
@@ -31,7 +31,12 @@ export function ensureSchemaOnce(): Promise<void> {
* constraints; CASCADE on the parents handles it but listing explicitly
* keeps the intent visible + lets us spot-check leakage. */
const TABLES_TO_WIPE: readonly string[] = [
+ 'workspace_cleanup_jobs',
'realtime_outbox',
+ 'audit_events',
+ 'llm_calls_rollup',
+ 'llm_calls',
+ 'agent_triages',
'shipping_events',
'shipping_regressions',
'shipping_friction_reports',
@@ -54,18 +59,29 @@ const TABLES_TO_WIPE: readonly string[] = [
'email_attachments',
'email_messages',
'email_contacts',
+ 'poll_votes',
'message_reactions',
+ 'tool_calls',
+ 'conversation_mutes',
'conversation_reads',
+ 'convene_transcript',
+ 'convene_sessions',
+ 'convening_info',
'conversation_counters',
'messages',
'conversation_members',
'conversations',
'agent_climate',
+ 'agent_autonomy',
'agent_workspace',
+ 'agent_memory',
'agent_runs',
'agent_events',
'agent_tasks',
'agent_log',
+ 'user_preferences',
+ 'company_invitations',
+ 'projects',
'company_members',
'participants',
'computers',
diff --git a/server/src/__integration__/workspace-management.test.ts b/server/src/__integration__/workspace-management.test.ts
new file mode 100644
index 0000000..bc2ef2b
--- /dev/null
+++ b/server/src/__integration__/workspace-management.test.ts
@@ -0,0 +1,481 @@
+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],
+ )
+
+ assert.equal(await isRuntimeAgentAuthorized('agent-managed', 'co-managed'), 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'`],
+ ] 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('agent-managed', 'co-managed'), 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 })
+})
diff --git a/server/src/__tests__/schema-migrations.test.ts b/server/src/__tests__/schema-migrations.test.ts
index ea4f1c2..b7c1e52 100644
--- a/server/src/__tests__/schema-migrations.test.ts
+++ b/server/src/__tests__/schema-migrations.test.ts
@@ -14,6 +14,7 @@ process.env.OPENAI_API_KEY ??= 'test-key'
const { computedBaselineMigrationChecksum } = await import('../db/migrate.js')
const { normalizedConversationMembersChecksum } = await import('../db/migrations/0002-normalized-conversation-members.js')
+const { workspaceCleanupJobsChecksum } = await import('../db/migrations/0003-workspace-cleanup-jobs.js')
const { verifySchemaCompatibility } = await import('../db/schema-version.js')
type SchemaVersionQueryable = import('../db/schema-version.js').SchemaVersionQueryable
@@ -27,6 +28,10 @@ test('the normalized membership migration matches its immutable manifest checksu
assert.equal(normalizedConversationMembersChecksum(), SCHEMA_MIGRATIONS[1].checksum)
})
+test('the workspace cleanup migration matches its immutable manifest checksum', () => {
+ assert.equal(workspaceCleanupJobsChecksum(), SCHEMA_MIGRATIONS[2].checksum)
+})
+
test('the migration owner accepts an exact prefix and reports its pending suffix', () => {
const empty = validateMigrationHistory([], { allowPending: true })
assert.equal(empty.currentVersion, 0)
diff --git a/server/src/api/router.ts b/server/src/api/router.ts
index 68365af..97c9776 100644
--- a/server/src/api/router.ts
+++ b/server/src/api/router.ts
@@ -5,8 +5,9 @@ import {
storageKeyFromPublicUrl, messageAttachmentStorageKey,
} from '../storage.js'
import { pool } from '../db/pool.js'
-import { CH_MESSAGE_NEW, CH_REACTIONS, CH_CONVO_UPDATED, CH_DOCS, CH_TYPING, CH_CALENDAR_EVENTS, CH_BOARDS, CH_STATUS, publish } from '../redis.js'
+import { CH_MESSAGE_NEW, CH_REACTIONS, CH_CONVO_UPDATED, CH_DOCS, CH_TYPING, CH_CALENDAR_EVENTS, CH_BOARDS, CH_STATUS, CH_WORKSPACES, publish } from '../redis.js'
import { enqueueBroadcast, nudgeRealtimeOutbox, withOutboxTransaction } from '../realtime-outbox.js'
+import { enqueueWorkspaceCleanup, nudgeWorkspaceCleanupWorker } from '../workspace-cleanup.js'
import { createPoll, castVote, closePoll, PollError } from '../polls.js'
import { env } from '../env.js'
import { publicBodyParserError } from '../body-parser-errors.js'
@@ -1473,11 +1474,391 @@ async function requireCompanyAdmin(req: Request & AuthedRequest, companyId: stri
)
if (rows.length === 0) throw new HttpError(403, 'not a member of this company')
if (!DEVTOOLS_ROLES.has(rows[0].role)) {
- throw new HttpError(403, 'only owners and admins can manage invitations')
+ throw new HttpError(403, 'only workspace owners and admins can perform this action')
}
return { userId: me, role: rows[0].role }
}
+type WorkspaceMemberRole = 'owner' | 'admin' | 'member'
+const MUTABLE_WORKSPACE_ROLES = new Set<WorkspaceMemberRole>(['admin', 'member'])
+
+interface WorkspaceMemberRow {
+ id: string
+ name: string
+ email: string
+ avatar_url: string | null
+ role: WorkspaceMemberRole
+ joined_at: string
+}
+
+function serializeWorkspaceMember(row: WorkspaceMemberRow) {
+ return {
+ id: row.id,
+ name: row.name,
+ email: row.email,
+ avatarUrl: row.avatar_url,
+ role: row.role,
+ joinedAt: new Date(row.joined_at).toISOString(),
+ }
+}
+
+async function enqueueWorkspaceMembership(client: PoolClient, event: {
+ companyId: string
+ kind: 'role_changed' | 'removed' | 'workspace_deleted'
+ recipientUserIds: string[]
+ actorId: string
+ userId?: string
+ role?: 'admin' | 'member'
+}): Promise<void> {
+ await enqueueBroadcast(client, CH_WORKSPACES, { type: 'workspace.membership', ...event })
+}
+
+/** List the human membership roster and its actual company_members role.
+ * `/participants` deliberately exposes an agent's job role instead, so it is
+ * not a safe source for workspace authorization UI. */
+api.get('/companies/:id/members', safe(async (req, res) => {
+ const companyId = String(req.params.id)
+ await requireCompanyAdmin(req, companyId)
+ const { rows } = await pool.query<WorkspaceMemberRow>(
+ `SELECT cm.user_id AS id,
+ u.display_name AS name,
+ u.email,
+ u.avatar_url,
+ cm.role,
+ cm.joined_at
+ FROM company_members cm
+ JOIN users u ON u.id = cm.user_id
+ WHERE cm.company_id = $1
+ ORDER BY CASE cm.role WHEN 'owner' THEN 0 WHEN 'admin' THEN 1 ELSE 2 END,
+ LOWER(u.display_name), cm.joined_at`,
+ [companyId],
+ )
+ res.json(rows.map(serializeWorkspaceMember))
+}))
+
+/** Change an existing member between member/admin. Ownership is immutable here
+ * and only the owner may change roles; ownership transfer needs its own flow. */
+api.patch('/companies/:id/members/:userId', safe(async (req, res) => {
+ const companyId = String(req.params.id)
+ const targetUserId = String(req.params.userId)
+ const requestedRole = String(req.body?.role ?? '') as WorkspaceMemberRole
+ if (!MUTABLE_WORKSPACE_ROLES.has(requestedRole)) {
+ throw new HttpError(400, 'role must be member or admin')
+ }
+ const nextRole = requestedRole as 'admin' | 'member'
+ const me = requireAuth(req)
+ const client = await pool.connect()
+ let previousRole: WorkspaceMemberRole
+ let updatedMember: WorkspaceMemberRow
+ try {
+ await client.query('BEGIN')
+ const { rows: actors } = await client.query<{ role: WorkspaceMemberRole; owner_user_id: string | null }>(
+ `SELECT actor.role, c.owner_user_id
+ FROM companies c
+ JOIN company_members actor
+ ON actor.company_id = c.id AND actor.user_id = $2
+ WHERE c.id = $1
+ FOR UPDATE OF c, actor`,
+ [companyId, me],
+ )
+ if (!actors[0]) throw new HttpError(403, 'not a member of this company')
+ if (actors[0].role !== 'owner') throw new HttpError(403, 'only the workspace owner can change member roles')
+
+ const { rows: targets } = await client.query<{ role: WorkspaceMemberRole }>(
+ `SELECT role FROM company_members
+ WHERE company_id = $1 AND user_id = $2
+ FOR UPDATE`,
+ [companyId, targetUserId],
+ )
+ if (!targets[0]) throw new HttpError(404, 'workspace member not found')
+ previousRole = targets[0].role
+ if (previousRole === 'owner' || actors[0].owner_user_id === targetUserId) {
+ throw new HttpError(409, 'workspace ownership cannot be changed here')
+ }
+ await client.query(
+ `UPDATE company_members SET role = $3
+ WHERE company_id = $1 AND user_id = $2`,
+ [companyId, targetUserId, nextRole],
+ )
+ const { rows: updatedMembers } = await client.query<WorkspaceMemberRow>(
+ `SELECT cm.user_id AS id, u.display_name AS name, u.email, u.avatar_url,
+ cm.role, cm.joined_at
+ FROM company_members cm JOIN users u ON u.id = cm.user_id
+ WHERE cm.company_id = $1 AND cm.user_id = $2`,
+ [companyId, targetUserId],
+ )
+ updatedMember = updatedMembers[0]
+ const { rows: managers } = await client.query<{ user_id: string }>(
+ `SELECT user_id FROM company_members
+ WHERE company_id = $1 AND role IN ('owner', 'admin')`,
+ [companyId],
+ )
+ await enqueueWorkspaceMembership(client, {
+ companyId, kind: 'role_changed',
+ recipientUserIds: [...new Set([targetUserId, ...managers.map((row) => row.user_id)])],
+ actorId: me, userId: targetUserId, role: nextRole,
+ })
+ await client.query('COMMIT')
+ nudgeRealtimeOutbox()
+ } catch (error) {
+ await client.query('ROLLBACK').catch(() => {})
+ throw error
+ } finally {
+ client.release()
+ }
+
+ const ip = req.socket.remoteAddress ?? null
+ const ua = (req.headers['user-agent'] as string | undefined) ?? null
+ await audit({
+ kind: 'workspace_member_role_changed', userId: me, companyId, ip, userAgent: ua,
+ detail: { targetUserId, previousRole, role: nextRole },
+ })
+ res.json({ ok: true, member: serializeWorkspaceMember(updatedMember) })
+}))
+
+/** Remove a human from a workspace while preserving authored history. The
+ * authorization rows, active participant state, and every conversation roster
+ * change in one transaction so there is no partial-access window. */
+api.delete('/companies/:id/members/:userId', safe(async (req, res) => {
+ const companyId = String(req.params.id)
+ const targetUserId = String(req.params.userId)
+ const me = requireAuth(req)
+ if (targetUserId === me) throw new HttpError(409, 'use a dedicated leave-workspace flow to remove yourself')
+
+ const client = await pool.connect()
+ let targetRole: WorkspaceMemberRole
+ let recipientUserIds: string[] = []
+ try {
+ await client.query('BEGIN')
+ const { rows: actors } = await client.query<{ role: WorkspaceMemberRole; owner_user_id: string | null }>(
+ `SELECT actor.role, c.owner_user_id
+ FROM companies c
+ JOIN company_members actor
+ ON actor.company_id = c.id AND actor.user_id = $2
+ WHERE c.id = $1
+ FOR UPDATE OF c, actor`,
+ [companyId, me],
+ )
+ const actor = actors[0]
+ if (!actor) throw new HttpError(403, 'not a member of this company')
+ if (actor.role !== 'owner' && actor.role !== 'admin') {
+ throw new HttpError(403, 'only owners and admins can remove workspace members')
+ }
+
+ const { rows: targets } = await client.query<{ role: WorkspaceMemberRole }>(
+ `SELECT role FROM company_members
+ WHERE company_id = $1 AND user_id = $2
+ FOR UPDATE`,
+ [companyId, targetUserId],
+ )
+ if (!targets[0]) throw new HttpError(404, 'workspace member not found')
+ targetRole = targets[0].role
+ if (targetRole === 'owner' || actor.owner_user_id === targetUserId) {
+ throw new HttpError(409, 'the workspace owner cannot be removed')
+ }
+ if (actor.role === 'admin' && targetRole !== 'member') {
+ throw new HttpError(403, 'admins can remove regular members only')
+ }
+
+ // Membership mutations lock participants first and conversations second,
+ // matching the normalized-membership helpers' global lock order.
+ const participantIds = [me, targetUserId].sort()
+ await client.query(
+ `SELECT id FROM participants
+ WHERE company_id = $1 AND id = ANY($2::text[])
+ ORDER BY id FOR UPDATE`,
+ [companyId, participantIds],
+ )
+ const { rows: conversations } = await client.query<{ id: string }>(
+ `SELECT c.id
+ FROM conversations c
+ JOIN conversation_members cm
+ ON cm.conversation_id = c.id AND cm.company_id = c.company_id
+ WHERE c.company_id = $1
+ AND cm.participant_id = $2
+ AND c.kind <> 'direct'
+ ORDER BY c.id
+ FOR UPDATE OF c`,
+ [companyId, targetUserId],
+ )
+ const conversationIds = conversations.map((row) => row.id)
+ if (conversationIds.length > 0) {
+ await client.query(
+ `DELETE FROM conversation_members
+ WHERE company_id = $1 AND participant_id = $2
+ AND conversation_id = ANY($3::text[])`,
+ [companyId, targetUserId, conversationIds],
+ )
+ await client.query(
+ `SELECT refresh_conversation_members_projection(id)
+ FROM unnest($1::text[]) affected(id)`,
+ [conversationIds],
+ )
+ }
+ await client.query(
+ `UPDATE participants
+ SET departed_at = NOW(), status = 'resting', status_updated_at = NOW()
+ WHERE company_id = $1 AND id = $2 AND kind = 'human'`,
+ [companyId, targetUserId],
+ )
+ await client.query(`DELETE FROM conversation_reads WHERE company_id = $1 AND user_id = $2`, [companyId, targetUserId])
+ await client.query(
+ `DELETE FROM conversation_mutes
+ WHERE user_id = $2
+ AND conversation_id IN (SELECT id FROM conversations WHERE company_id = $1)`,
+ [companyId, targetUserId],
+ )
+ const { rows: recipients } = await client.query<{ user_id: string }>(
+ `SELECT user_id FROM company_members WHERE company_id = $1`, [companyId],
+ )
+ recipientUserIds = recipients.map((row) => row.user_id)
+ await client.query(
+ `DELETE FROM company_members WHERE company_id = $1 AND user_id = $2`,
+ [companyId, targetUserId],
+ )
+ await enqueueWorkspaceMembership(client, {
+ companyId, kind: 'removed', recipientUserIds,
+ actorId: me, userId: targetUserId,
+ })
+ await client.query('COMMIT')
+ nudgeRealtimeOutbox()
+ } catch (error) {
+ await client.query('ROLLBACK').catch(() => {})
+ throw error
+ } finally {
+ client.release()
+ }
+
+ const ip = req.socket.remoteAddress ?? null
+ const ua = (req.headers['user-agent'] as string | undefined) ?? null
+ await audit({
+ kind: 'workspace_member_removed', userId: me, companyId, ip, userAgent: ua,
+ detail: { targetUserId, previousRole: targetRole },
+ })
+ res.json({ ok: true })
+}))
+
+/** Hard-delete a workspace's tenant data. The schema contains both modern
+ * company FKs and legacy soft company_id columns, so the explicit deletes are
+ * intentional; relying on DELETE companies CASCADE alone would leave orphans. */
+api.delete('/companies/:id', safe(async (req, res) => {
+ const companyId = String(req.params.id)
+ const confirmation = String(req.body?.confirmation ?? '').trim()
+ const me = requireAuth(req)
+ const client = await pool.connect()
+ let companyName = ''
+ let memberIds: string[] = []
+ let agentIds: string[] = []
+ const storageKeys = new Set<string>()
+ let nextCompanyId: string | null = null
+ try {
+ await client.query('BEGIN')
+ const { rows: companies } = await client.query<{
+ name: string; owner_user_id: string | null; role: WorkspaceMemberRole
+ }>(
+ `SELECT c.name, c.owner_user_id, cm.role
+ FROM companies c
+ JOIN company_members cm ON cm.company_id = c.id AND cm.user_id = $2
+ WHERE c.id = $1
+ FOR UPDATE OF c, cm`,
+ [companyId, me],
+ )
+ const company = companies[0]
+ if (!company) throw new HttpError(404, 'workspace not found')
+ if (company.role !== 'owner' || (company.owner_user_id && company.owner_user_id !== me)) {
+ throw new HttpError(403, 'only the workspace owner can delete it')
+ }
+ companyName = company.name
+ if (!confirmation || confirmation !== companyName) {
+ throw new HttpError(400, 'type the workspace name exactly to confirm deletion')
+ }
+ const { rows: alternatives } = await client.query<{ company_id: string }>(
+ `SELECT company_id FROM company_members
+ WHERE user_id = $1 AND company_id <> $2
+ ORDER BY joined_at ASC LIMIT 1`,
+ [me, companyId],
+ )
+ nextCompanyId = alternatives[0]?.company_id ?? null
+ if (!nextCompanyId) throw new HttpError(409, 'you cannot delete your only workspace')
+
+ const { rows: members } = await client.query<{ user_id: string }>(
+ `SELECT user_id FROM company_members WHERE company_id = $1`, [companyId],
+ )
+ memberIds = members.map((row) => row.user_id)
+ const { rows: agents } = await client.query<{ id: string; avatar_url: string | null }>(
+ `SELECT id, avatar_url FROM participants WHERE company_id = $1 AND kind = 'agent'`, [companyId],
+ )
+ agentIds = agents.map((row) => row.id)
+ for (const row of agents) {
+ if (!row.avatar_url) continue
+ const key = storageKeyFromPublicUrl(row.avatar_url)
+ if (key) storageKeys.add(key)
+ }
+ const { rows: emailFiles } = await client.query<{ storage_key: string | null }>(
+ `SELECT storage_key FROM email_attachments WHERE company_id = $1`, [companyId],
+ )
+ for (const row of emailFiles) {
+ const key = row.storage_key ? normalizeStorageKey(row.storage_key) : null
+ if (key) storageKeys.add(key)
+ }
+ const { rows: messageFiles } = await client.query<{ attachment: unknown }>(
+ `SELECT attachment FROM messages WHERE company_id = $1 AND attachment IS NOT NULL`, [companyId],
+ )
+ for (const row of messageFiles) {
+ const candidates = Array.isArray(row.attachment) ? row.attachment : [row.attachment]
+ for (const candidate of candidates) {
+ if (!candidate || typeof candidate !== 'object') continue
+ const key = messageAttachmentStorageKey(candidate as { key?: unknown; url?: unknown })
+ if (key) storageKeys.add(key)
+ }
+ }
+
+ // Child/root rows with soft company_id references. FK-backed trees such as
+ // boards, calendar, projects, invitations, and shipping cascade from the
+ // final companies delete below.
+ const softScopedTables = [
+ 'document_mentions', 'email_attachments', 'email_messages', 'email_contacts',
+ 'poll_votes', 'message_reactions', 'tool_calls', 'conversation_reads',
+ 'agent_events', 'agent_runs', 'agent_triages',
+ 'agent_workspace', 'agent_memory', 'agent_log', 'agent_tasks',
+ 'agent_climate', 'computers',
+ ] as const
+ for (const table of softScopedTables) {
+ await client.query(`DELETE FROM ${table} WHERE company_id = $1`, [companyId])
+ }
+ if (agentIds.length > 0) {
+ await client.query(`DELETE FROM board_mention_reads WHERE user_id = ANY($1::text[])`, [agentIds])
+ }
+ await client.query(`DELETE FROM documents WHERE company_id = $1`, [companyId])
+ await client.query(`DELETE FROM conversations WHERE company_id = $1`, [companyId])
+ await client.query(`DELETE FROM participants WHERE company_id = $1`, [companyId])
+ // Keep the billing/usage ledger (llm_calls + llm_calls_rollup) and global
+ // user settings. They are intentionally not tenant-owned data.
+ await enqueueWorkspaceCleanup(client, { companyId, agentIds, storageKeys: [...storageKeys] })
+ await enqueueWorkspaceMembership(client, {
+ companyId, kind: 'workspace_deleted', recipientUserIds: memberIds,
+ actorId: me,
+ })
+ await client.query(`DELETE FROM companies WHERE id = $1`, [companyId])
+ await client.query('COMMIT')
+ nudgeRealtimeOutbox()
+ nudgeWorkspaceCleanupWorker()
+ } catch (error) {
+ await client.query('ROLLBACK').catch(() => {})
+ throw error
+ } finally {
+ client.release()
+ }
+
+ const ip = req.socket.remoteAddress ?? null
+ const ua = (req.headers['user-agent'] as string | undefined) ?? null
+ await audit({
+ kind: 'workspace_deleted', userId: me, companyId, ip, userAgent: ua,
+ detail: { name: companyName, memberCount: memberIds.length, agentCount: agentIds.length },
+ })
+ res.json({ ok: true, nextCompanyId })
+}))
+
/** Build the public-facing accept URL for an invite — always an https web
* origin (e.g. https://app.cumora.ai/invite/<token>). The web bundle hosted
* there has its API origin baked in at build time (VITE_CUMORA_API_BASE), so
@@ -1555,7 +1936,7 @@ api.get('/companies/:id/invitations', safe(async (req, res) => {
* hash, so this is the only chance to copy the link. */
api.post('/companies/:id/invitations', safe(async (req, res) => {
const companyId = String(req.params.id)
- const { userId: me } = await requireCompanyAdmin(req, companyId)
+ const { userId: me, role: actorRole } = await requireCompanyAdmin(req, companyId)
const body = req.body ?? {}
const rawEmail = typeof body.email === 'string' ? body.email.trim() : ''
const email = rawEmail ? rawEmail.toLowerCase() : null
@@ -1564,6 +1945,9 @@ api.post('/companies/:id/invitations', safe(async (req, res) => {
}
const role = typeof body.role === 'string' && INVITE_ALLOWED_ROLES.has(body.role)
? body.role : 'member'
+ if (actorRole === 'admin' && role === 'admin') {
+ throw new HttpError(403, 'only the workspace owner can invite another admin')
+ }
const note = typeof body.note === 'string' ? body.note.trim().slice(0, 280) || null : null
const multiUse = body.multiUse === true || (!email && body.maxUses !== 1)
const requestedMaxUses = Number(body.maxUses ?? (email ? 1 : INVITE_MAX_LINK_USES))
@@ -1825,7 +2209,13 @@ api.post('/invitations/:token/accept', safe(async (req, res) => {
await client.query(
`INSERT INTO participants (id, kind, name, role, initial, avatar_bg, avatar_url, status, company_id)
VALUES ($1, 'human', $2, NULL, $3, '#FF8870', $4, 'avail', $5)
- ON CONFLICT (id, company_id) DO NOTHING`,
+ ON CONFLICT (id, company_id) DO UPDATE
+ SET name = EXCLUDED.name,
+ initial = EXCLUDED.initial,
+ avatar_url = EXCLUDED.avatar_url,
+ status = 'avail',
+ status_updated_at = NOW(),
+ departed_at = NULL`,
[me, displayName, displayName.charAt(0).toUpperCase(),
userAvatar, inv.company_id],
)
diff --git a/server/src/db/migrate.ts b/server/src/db/migrate.ts
index c0f30bf..4e9b47c 100644
--- a/server/src/db/migrate.ts
+++ b/server/src/db/migrate.ts
@@ -17,6 +17,10 @@ import {
NORMALIZED_CONVERSATION_MEMBERS_SQL,
normalizedConversationMembersChecksum,
} from './migrations/0002-normalized-conversation-members.js'
+import {
+ WORKSPACE_CLEANUP_JOBS_SQL,
+ workspaceCleanupJobsChecksum,
+} from './migrations/0003-workspace-cleanup-jobs.js'
/** Frozen data backfill embedded in migration 0001. Exported so its behavior
* can be exercised against PostgreSQL without replaying the whole migration. */
@@ -2094,6 +2098,10 @@ async function applyNormalizedConversationMembers(client: import('pg').PoolClien
await client.query(NORMALIZED_CONVERSATION_MEMBERS_SQL)
}
+async function applyWorkspaceCleanupJobs(client: import('pg').PoolClient): Promise<void> {
+ await client.query(WORKSPACE_CLEANUP_JOBS_SQL)
+}
+
const VERSIONED_MIGRATIONS: readonly VersionedMigration[] = [
{
...SCHEMA_MIGRATIONS[0],
@@ -2105,6 +2113,11 @@ const VERSIONED_MIGRATIONS: readonly VersionedMigration[] = [
sourceChecksum: normalizedConversationMembersChecksum(),
up: applyNormalizedConversationMembers,
},
+ {
+ ...SCHEMA_MIGRATIONS[2],
+ sourceChecksum: workspaceCleanupJobsChecksum(),
+ up: applyWorkspaceCleanupJobs,
+ },
]
function validateMigrationDefinitions(): void {
diff --git a/server/src/db/migrations/0003-workspace-cleanup-jobs.ts b/server/src/db/migrations/0003-workspace-cleanup-jobs.ts
new file mode 100644
index 0000000..92e5a38
--- /dev/null
+++ b/server/src/db/migrations/0003-workspace-cleanup-jobs.ts
@@ -0,0 +1,37 @@
+import { createHash } from 'node:crypto'
+
+/**
+ * Migration 0003: durable cleanup work for deleted workspaces.
+ *
+ * The row deliberately has no company FK: it must survive the transaction
+ * that deletes the company so external storage and runtime resources can be
+ * retried after a crash or transient control-plane failure.
+ */
+export const WORKSPACE_CLEANUP_JOBS_SQL = `
+CREATE TABLE workspace_cleanup_jobs (
+ id TEXT PRIMARY KEY,
+ company_id TEXT NOT NULL,
+ agent_ids TEXT[] NOT NULL DEFAULT '{}',
+ storage_keys TEXT[] NOT NULL DEFAULT '{}',
+ attempts INTEGER NOT NULL DEFAULT 0 CHECK (attempts >= 0),
+ available_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW(),
+ locked_by TEXT,
+ locked_until TIMESTAMP WITH TIME ZONE,
+ last_error TEXT,
+ completed_at TIMESTAMP WITH TIME ZONE,
+ created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW(),
+ updated_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW()
+);
+
+CREATE INDEX idx_workspace_cleanup_jobs_pending
+ ON workspace_cleanup_jobs(available_at, created_at, id)
+ WHERE completed_at IS NULL;
+
+CREATE INDEX idx_workspace_cleanup_jobs_completed
+ ON workspace_cleanup_jobs(completed_at)
+ WHERE completed_at IS NOT NULL;
+`
+
+export function workspaceCleanupJobsChecksum(): string {
+ return createHash('sha256').update(WORKSPACE_CLEANUP_JOBS_SQL).digest('hex')
+}
diff --git a/server/src/db/migrations/manifest.ts b/server/src/db/migrations/manifest.ts
index 9c24a28..70597f2 100644
--- a/server/src/db/migrations/manifest.ts
+++ b/server/src/db/migrations/manifest.ts
@@ -27,12 +27,17 @@ export const SCHEMA_MIGRATIONS = [
name: '0002_normalized_conversation_members',
checksum: '489abe15a28b6c1ee11e7a3e03f79c2949574687333de1d97e7b7eff33c6d2b3',
},
+ {
+ version: 3,
+ name: '0003_workspace_cleanup_jobs',
+ checksum: 'cd4047a09fb585ba166e7e0a48a21169168da567728dcb63ae8e6ff5bd204d89',
+ },
] as const satisfies readonly MigrationMetadata[]
/** This build intentionally supports one exact schema range. Expand/contract
* releases may widen the range, but both bounds must remain explicit. */
-export const MIN_SUPPORTED_SCHEMA_VERSION = 2
-export const MAX_SUPPORTED_SCHEMA_VERSION = 2
+export const MIN_SUPPORTED_SCHEMA_VERSION = 3
+export const MAX_SUPPORTED_SCHEMA_VERSION = 3
function assertManifestShape(): void {
for (let i = 0; i < SCHEMA_MIGRATIONS.length; i++) {
diff --git a/server/src/env.ts b/server/src/env.ts
index 18d355d..393ada7 100644
--- a/server/src/env.ts
+++ b/server/src/env.ts
@@ -412,6 +412,14 @@ export const env = {
DB_GC_LLM_CALLS_DAYS: Number(process.env.DB_GC_LLM_CALLS_DAYS ?? 90),
/** Days past expires_at before a ws_ticket row is reaped. */
DB_GC_WS_TICKETS_DAYS: Number(process.env.DB_GC_WS_TICKETS_DAYS ?? 1),
+ /** Durable external-resource cleanup after workspace deletion. Set the
+ * interval to 0 to leave jobs queued for a separately invoked worker. */
+ WORKSPACE_CLEANUP_INTERVAL_MS: Number(process.env.WORKSPACE_CLEANUP_INTERVAL_MS ?? 60_000),
+ /** Explicitly enable Kubernetes Pod/PVC cleanup. Local and integration
+ * environments default off without relying on database-name heuristics. */
+ WORKSPACE_RUNTIME_CLEANUP_ENABLED: ['1', 'true', 'yes', 'on'].includes(
+ (process.env.WORKSPACE_RUNTIME_CLEANUP_ENABLED ?? '').toLowerCase(),
+ ),
/** Interval between poll-expiration sweeps. Defaults to 60s. The sweep
* flips polls past their expiresAt to closed and broadcasts the close
* event. Set to 0 to disable (polls then stay open forever even after
diff --git a/server/src/index.ts b/server/src/index.ts
index 9493066..b342acb 100644
--- a/server/src/index.ts
+++ b/server/src/index.ts
@@ -35,6 +35,7 @@ import { seedAdmins } from './admin.js'
import { notifyAlert } from './alerting.js'
import { startShippingMaintenance } from './shipping-maintenance.js'
import { startRealtimeOutboxWorker, stopRealtimeOutboxWorker } from './realtime-outbox.js'
+import { startWorkspaceCleanupWorker, stopWorkspaceCleanupWorker } from './workspace-cleanup.js'
async function main() {
const schemaVersion = await verifySchemaWithBootRetry()
@@ -316,6 +317,7 @@ async function main() {
// PostgreSQL owns command completion; Redis delivery is retried here after
// commit. Start after the schema ensure so the outbox table is guaranteed.
startRealtimeOutboxWorker()
+ startWorkspaceCleanupWorker()
// Agent-pod garbage collection — sweep Succeeded/Failed/Unknown
// agent pods older than 5min. Plain Pods don't have TTL-after-
@@ -376,6 +378,7 @@ async function main() {
console.log(`[shutdown] ${sig}`)
server.close()
stopRealtimeOutboxWorker()
+ stopWorkspaceCleanupWorker()
try { await pool.end() } catch { /* ignore */ }
try { redis.disconnect() } catch { /* ignore */ }
process.exit(0)
diff --git a/server/src/redis.ts b/server/src/redis.ts
index 4140509..718be6d 100644
--- a/server/src/redis.ts
+++ b/server/src/redis.ts
@@ -61,6 +61,10 @@ export const CH_CALENDAR_REMINDER = 'cumora:calendar.reminder'
* update / delete / cancel / run-now / dispatcher auto-done so every
* client in the company can patch their Calendar view in real time. */
export const CH_CALENDAR_EVENTS = 'cumora:calendar.events'
+/** Workspace membership/role invalidation. Unlike ordinary tenant broadcasts,
+ * removal/deletion events must still reach users whose company_members row has
+ * already gone, so the WS bridge routes this channel by recipientUserIds. */
+export const CH_WORKSPACES = 'cumora:workspaces'
/* === Event types ===
*
@@ -379,6 +383,15 @@ export interface CalendarEventChangedEvent extends TenantTagged {
actorId: string | null
}
+export interface WorkspaceMembershipEvent extends TenantTagged {
+ type: 'workspace.membership'
+ kind: 'role_changed' | 'removed' | 'workspace_deleted'
+ recipientUserIds: string[]
+ actorId: string
+ userId?: string
+ role?: 'admin' | 'member'
+}
+
/** Poll state changed — a new vote was cast, an existing vote was changed,
* or the poll was closed (manually or by the expiration sweeper). Carries
* the full denormalized poll snapshot so renderers can patch in place
@@ -416,6 +429,7 @@ export type BroadcastEvent = MessageNewEvent | MessageDeltaEvent | TypingEvent
| CalendarEventChangedEvent
| PollUpdatedEvent
| ComputerStatusEvent
+ | WorkspaceMembershipEvent
export async function publish(channel: string, event: BroadcastEvent): Promise<void> {
await redis.publish(channel, JSON.stringify(event))
diff --git a/server/src/storage.ts b/server/src/storage.ts
index b93a183..9271289 100644
--- a/server/src/storage.ts
+++ b/server/src/storage.ts
@@ -146,7 +146,12 @@ class LocalStorage implements Storage {
async deleteObject(key: string): Promise<boolean> {
const path = join(UPLOAD_DIR, key)
try { await unlink(path); return true }
- catch { return false }
+ catch (error) {
+ // Deletion is idempotent: a prior successful attempt may have removed
+ // the file before the durable cleanup job could be marked complete.
+ if ((error as NodeJS.ErrnoException).code === 'ENOENT') return true
+ return false
+ }
}
}
diff --git a/server/src/workspace-cleanup.ts b/server/src/workspace-cleanup.ts
new file mode 100644
index 0000000..5a49bc9
--- /dev/null
+++ b/server/src/workspace-cleanup.ts
@@ -0,0 +1,230 @@
+import { randomUUID } from 'node:crypto'
+import type { PoolClient } from 'pg'
+import { pool } from './db/pool.js'
+import { env } from './env.js'
+import {
+ messageAttachmentStorageKey,
+ normalizeStorageKey,
+ storage,
+ storageKeyFromPublicUrl,
+} from './storage.js'
+
+interface CleanupJob {
+ id: string
+ agent_ids: string[]
+ storage_keys: string[]
+ attempts: number
+}
+
+export interface WorkspaceCleanupResult {
+ claimed: number
+ completed: number
+ failed: number
+}
+
+export interface WorkspaceCleanupDependencies {
+ deleteStorageObject: (key: string) => Promise<boolean>
+ deleteAgentRuntime: (agentId: string) => Promise<void>
+}
+
+const CLAIM_LEASE_MS = 60_000
+const BATCH_SIZE = 8
+const COMPLETED_RETENTION_DAYS = 7
+const workerId = `workspace-cleanup-${process.pid}-${randomUUID().slice(0, 8)}`
+let workerTimer: NodeJS.Timeout | null = null
+let workerRunning = false
+
+export async function enqueueWorkspaceCleanup(
+ client: PoolClient,
+ input: { companyId: string; agentIds: string[]; storageKeys: string[] },
+): Promise<string | null> {
+ const agentIds = [...new Set(input.agentIds)]
+ const storageKeys = [...new Set(input.storageKeys.map(normalizeStorageKey).filter((key): key is string => !!key))]
+ if (agentIds.length === 0 && storageKeys.length === 0) return null
+ const id = randomUUID()
+ await client.query(
+ `INSERT INTO workspace_cleanup_jobs (id, company_id, agent_ids, storage_keys)
+ VALUES ($1, $2, $3::text[], $4::text[])`,
+ [id, input.companyId, agentIds, storageKeys],
+ )
+ return id
+}
+
+async function claimBatch(limit: number): Promise<CleanupJob[]> {
+ const { rows } = await pool.query<CleanupJob>(
+ `WITH candidates AS (
+ SELECT id
+ FROM workspace_cleanup_jobs
+ WHERE completed_at IS NULL
+ AND available_at <= NOW()
+ AND (locked_until IS NULL OR locked_until < NOW())
+ ORDER BY created_at, id
+ LIMIT $1
+ FOR UPDATE SKIP LOCKED
+ )
+ UPDATE workspace_cleanup_jobs j
+ SET locked_by = $2,
+ locked_until = NOW() + ($3 * INTERVAL '1 millisecond'),
+ updated_at = NOW()
+ FROM candidates c
+ WHERE j.id = c.id
+ RETURNING j.id, j.agent_ids, j.storage_keys, j.attempts`,
+ [limit, workerId, CLAIM_LEASE_MS],
+ )
+ return rows
+}
+
+async function findReferencedStorageKeys(keys: string[]): Promise<Set<string>> {
+ if (keys.length === 0) return new Set()
+ const referenced = new Set<string>()
+
+ const [emailFiles, messageFiles, avatars] = await Promise.all([
+ pool.query<{ storage_key: string }>(
+ `SELECT storage_key FROM email_attachments WHERE storage_key = ANY($1::text[])`,
+ [keys],
+ ),
+ pool.query<{ attachment: unknown }>(
+ `SELECT attachment
+ FROM messages m
+ WHERE attachment IS NOT NULL
+ AND EXISTS (
+ SELECT 1 FROM unnest($1::text[]) candidate(key)
+ WHERE m.attachment::text LIKE '%' || candidate.key || '%'
+ )`,
+ [keys],
+ ),
+ pool.query<{ avatar_url: string }>(
+ `SELECT avatar_url
+ FROM participants p
+ WHERE avatar_url IS NOT NULL
+ AND EXISTS (
+ SELECT 1 FROM unnest($1::text[]) candidate(key)
+ WHERE p.avatar_url LIKE '%' || candidate.key || '%'
+ )`,
+ [keys],
+ ),
+ ])
+
+ for (const row of emailFiles.rows) {
+ const key = normalizeStorageKey(row.storage_key)
+ if (key && keys.includes(key)) referenced.add(key)
+ }
+ for (const row of messageFiles.rows) {
+ const attachments = Array.isArray(row.attachment) ? row.attachment : [row.attachment]
+ for (const attachment of attachments) {
+ if (!attachment || typeof attachment !== 'object') continue
+ const key = messageAttachmentStorageKey(attachment as { key?: unknown; url?: unknown })
+ if (key && keys.includes(key)) referenced.add(key)
+ }
+ }
+ for (const row of avatars.rows) {
+ const key = storageKeyFromPublicUrl(row.avatar_url)
+ if (key && keys.includes(key)) referenced.add(key)
+ }
+ return referenced
+}
+
+async function defaultDeleteAgentRuntime(agentId: string): Promise<void> {
+ if (!env.WORKSPACE_RUNTIME_CLEANUP_ENABLED) return
+ const { deletePod, deleteChromeProfilePvc } = await import('./agents/runtime/orchestrator.js')
+ await Promise.all([deletePod(agentId), deleteChromeProfilePvc(agentId)])
+}
+
+async function performCleanup(job: CleanupJob, dependencies: WorkspaceCleanupDependencies): Promise<void> {
+ const referenced = await findReferencedStorageKeys(job.storage_keys)
+ for (const key of job.storage_keys) {
+ if (referenced.has(key)) continue
+ if (!await dependencies.deleteStorageObject(key)) {
+ throw new Error(`storage deletion failed for ${key}`)
+ }
+ }
+ await Promise.all(job.agent_ids.map(dependencies.deleteAgentRuntime))
+}
+
+async function markCompleted(id: string): Promise<void> {
+ await pool.query(
+ `UPDATE workspace_cleanup_jobs
+ SET completed_at = NOW(), locked_by = NULL, locked_until = NULL,
+ last_error = NULL, updated_at = NOW()
+ WHERE id = $1 AND locked_by = $2`,
+ [id, workerId],
+ )
+}
+
+async function markFailed(job: CleanupJob, error: unknown): Promise<void> {
+ const message = error instanceof Error ? error.message : String(error)
+ const delayMs = Math.min(60 * 60_000, 1_000 * (2 ** Math.min(job.attempts, 12)))
+ await pool.query(
+ `UPDATE workspace_cleanup_jobs
+ SET attempts = attempts + 1,
+ available_at = NOW() + ($3 * INTERVAL '1 millisecond'),
+ locked_by = NULL, locked_until = NULL,
+ last_error = LEFT($4, 1000), updated_at = NOW()
+ WHERE id = $1 AND locked_by = $2`,
+ [job.id, workerId, delayMs, message],
+ )
+}
+
+async function cleanupCompletedRows(): Promise<void> {
+ await pool.query(
+ `DELETE FROM workspace_cleanup_jobs
+ WHERE completed_at <= NOW() - ($1 * INTERVAL '1 day')`,
+ [COMPLETED_RETENTION_DAYS],
+ )
+}
+
+/** Drain one bounded batch. Exported so integration tests can inject external
+ * failures and prove that the durable job remains retryable. */
+export async function drainWorkspaceCleanupJobs(options: {
+ dependencies?: Partial<WorkspaceCleanupDependencies>
+ batchSize?: number
+} = {}): Promise<WorkspaceCleanupResult> {
+ const dependencies: WorkspaceCleanupDependencies = {
+ deleteStorageObject: options.dependencies?.deleteStorageObject ?? ((key) => storage.deleteObject(key)),
+ deleteAgentRuntime: options.dependencies?.deleteAgentRuntime ?? defaultDeleteAgentRuntime,
+ }
+ await cleanupCompletedRows()
+ const rows = await claimBatch(Math.max(1, Math.min(options.batchSize ?? BATCH_SIZE, 32)))
+ let completed = 0
+ let failed = 0
+ await Promise.all(rows.map(async (row) => {
+ try {
+ await performCleanup(row, dependencies)
+ await markCompleted(row.id)
+ completed += 1
+ } catch (error) {
+ await markFailed(row, error)
+ failed += 1
+ }
+ }))
+ return { claimed: rows.length, completed, failed }
+}
+
+function runWorkerTick(): void {
+ if (workerRunning) return
+ workerRunning = true
+ void drainWorkspaceCleanupJobs()
+ .then((result) => {
+ if (result.failed > 0) console.warn(`[workspace-cleanup] ${result.failed} job(s) delayed; cleanup will retry`)
+ })
+ .catch((error) => console.warn('[workspace-cleanup] drain failed', error instanceof Error ? error.message : error))
+ .finally(() => { workerRunning = false })
+}
+
+export function nudgeWorkspaceCleanupWorker(): void {
+ if (workerTimer) setImmediate(runWorkerTick)
+}
+
+export function startWorkspaceCleanupWorker(): NodeJS.Timeout | null {
+ if (workerTimer || env.WORKSPACE_CLEANUP_INTERVAL_MS <= 0) return workerTimer
+ runWorkerTick()
+ workerTimer = setInterval(runWorkerTick, env.WORKSPACE_CLEANUP_INTERVAL_MS)
+ workerTimer.unref()
+ console.log(`[boot] workspace cleanup running every ${env.WORKSPACE_CLEANUP_INTERVAL_MS}ms`)
+ return workerTimer
+}
+
+export function stopWorkspaceCleanupWorker(): void {
+ if (workerTimer) clearInterval(workerTimer)
+ workerTimer = null
+}
diff --git a/server/src/ws.ts b/server/src/ws.ts
index 073d053..9a107a2 100644
--- a/server/src/ws.ts
+++ b/server/src/ws.ts
@@ -6,6 +6,7 @@ import {
CH_STATUS, CH_REACTIONS, CH_POLLS,
CH_GROUP_PULLED, CH_CONVO_UPDATED, CH_CONVENE,
CH_BOARDS, CH_DOCS, CH_CALENDAR_REMINDER, CH_CALENDAR_EVENTS, CH_DOC_MENTION,
+ CH_WORKSPACES,
publish,
type DocMentionEvent,
} from './redis.js'
@@ -161,6 +162,19 @@ export async function resolveWsEventRecipientUserIds(
): Promise<Set<string>> {
const companyId = typeof event.companyId === 'string' ? event.companyId : ''
if (!companyId) return new Set()
+ // Membership invalidations are terminal, user-targeted frames. Looking the
+ // recipients up through company_members would drop the exact event that tells
+ // a removed user to evict the workspace from their client. The publisher is a
+ // server-only mutation path and users are still checked for account liveness.
+ if (event.type === 'workspace.membership') {
+ const requested = [...new Set((event.recipientUserIds ?? []).filter((id) => typeof id === 'string'))]
+ if (requested.length === 0) return new Set()
+ const { rows } = await pool.query<{ id: string }>(
+ `SELECT id FROM users WHERE id = ANY($1::text[]) AND deleted_at IS NULL`,
+ [requested],
+ )
+ return new Set(rows.map((row) => row.id))
+ }
const targetedUserIds = event.type === 'doc.mention'
? event.mentionedIds
: event.type === 'calendar.reminder'
@@ -891,7 +905,7 @@ export function attachWebSocket(httpServer: Server) {
CH_MESSAGE_NEW, CH_MESSAGE_DELTA, CH_TYPING,
CH_STATUS, CH_REACTIONS, CH_POLLS,
CH_GROUP_PULLED, CH_CONVO_UPDATED, CH_CONVENE,
- CH_BOARDS, CH_DOCS, CH_CALENDAR_REMINDER, CH_CALENDAR_EVENTS, CH_DOC_MENTION,
+ CH_BOARDS, CH_DOCS, CH_CALENDAR_REMINDER, CH_CALENDAR_EVENTS, CH_DOC_MENTION, CH_WORKSPACES,
).then((count) => {
console.log(`[ws] subscribed to ${count} redis channels`)
})
diff --git a/src/App.tsx b/src/App.tsx
index 930be96..179fd9e 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -26,6 +26,8 @@ import { UpdateBanner, UpdaterDialog } from '@/components/UpdaterDialog'
import { AdminApp } from '@/admin/AdminApp'
import { WaitlistConfirmedScreen, consumeWaitlistFragment } from '@/admin/WaitlistConfirmedScreen'
import { SuspendedScreen, consumeSuspendedFragment } from '@/admin/SuspendedScreen'
+import { NoWorkspaceScreen } from '@/components/NoWorkspaceScreen'
+import { WorkspaceSessionBridge } from '@/components/WorkspaceSessionBridge'
import '@/admin/admin.css'
/** True iff this browser tab is for the admin panel. On prod the
@@ -262,7 +264,10 @@ export function App() {
return (
<AuthGate>
<ErrorBoundary>
- <AuthedApp key={`${userId ?? 'anon'}::${companyId ?? 'none'}`} />
+ <WorkspaceSessionBridge />
+ {userId && !companyId
+ ? <NoWorkspaceScreen />
+ : <AuthedApp key={`${userId ?? 'anon'}::${companyId ?? 'none'}`} />}
</ErrorBoundary>
</AuthGate>
)
diff --git a/src/api/client.ts b/src/api/client.ts
index a5dc9c1..c375e04 100644
--- a/src/api/client.ts
+++ b/src/api/client.ts
@@ -1,10 +1,10 @@
+import { getActiveCompanyId, getAuthToken, useAuth } from '@/stores/auth'
import type {
- Message, Status,
- BoardSummary, BoardSnapshot, BoardCardComment, BoardCardLookup,
- CalendarEvent, CalendarEventKind, CalendarEventStatus, CalendarDispatch, RecurrenceRule,
- CalendarReminderChannel,ComputerStatus, ComputerKind, EngineId, DetectedEngine,
+ BoardCardComment, BoardCardLookup, BoardSnapshot, BoardSummary,
+ CalendarDispatch, CalendarEvent, CalendarEventKind, CalendarEventStatus,
+ CalendarReminderChannel, ComputerKind, ComputerStatus, DetectedEngine, EngineId,
+ Message, RecurrenceRule, Status,
} from '@/types'
-import { getAuthToken, getActiveCompanyId, useAuth } from '@/stores/auth'
const DEVTOOLS_KEY = 'cumora.devtools.enabled'
const SERVER_URL_KEY = 'cumora.serverUrl'
@@ -640,6 +640,17 @@ export interface ApiInvitationEmailDelivery {
skipped: 'no_email_config' | null
}
+export type WorkspaceRole = 'owner' | 'admin' | 'member'
+
+export interface ApiWorkspaceMember {
+ id: string
+ name: string
+ email: string
+ avatarUrl: string | null
+ role: WorkspaceRole
+ joinedAt: string
+}
+
export type ApiInvitationPreviewStatus =
| 'valid' | 'revoked' | 'expired' | 'consumed'
| 'wrong_email' | 'already_member' | 'not_found'
@@ -900,6 +911,22 @@ export const api = {
http<{ id: string; name: string; slug: string; role: string }>('/companies', {
method: 'POST', body: JSON.stringify({ name }),
}),
+ listWorkspaceMembers: (companyId: string) =>
+ http<ApiWorkspaceMember[]>(`/companies/${encodeURIComponent(companyId)}/members`),
+ updateWorkspaceMemberRole: (companyId: string, userId: string, role: 'member' | 'admin') =>
+ http<{ ok: true; member: ApiWorkspaceMember }>(
+ `/companies/${encodeURIComponent(companyId)}/members/${encodeURIComponent(userId)}`,
+ { method: 'PATCH', body: JSON.stringify({ role }) },
+ ),
+ removeWorkspaceMember: (companyId: string, userId: string) =>
+ http<{ ok: true }>(
+ `/companies/${encodeURIComponent(companyId)}/members/${encodeURIComponent(userId)}`,
+ { method: 'DELETE' },
+ ),
+ deleteCompany: (companyId: string, confirmation: string) =>
+ http<{ ok: true; nextCompanyId: string }>(`/companies/${encodeURIComponent(companyId)}`, {
+ method: 'DELETE', body: JSON.stringify({ confirmation }),
+ }),
/** Owner/admin-only: list every invitation (active + historical) for a
* company so the management UI can show recent activity. */
listInvitations: (companyId: string) =>
@@ -1545,6 +1572,15 @@ export type WsEvent =
tallies: import('../types.js').PollTally[]
actorId: string | null
}
+ | {
+ type: 'workspace.membership'
+ kind: 'role_changed' | 'removed' | 'workspace_deleted'
+ companyId: string
+ recipientUserIds: string[]
+ actorId: string
+ userId?: string
+ role?: 'admin' | 'member'
+ }
type Listener = (e: WsEvent) => void
diff --git a/src/components/CompanySwitcher.tsx b/src/components/CompanySwitcher.tsx
index a3724f9..202e449 100644
--- a/src/components/CompanySwitcher.tsx
+++ b/src/components/CompanySwitcher.tsx
@@ -10,10 +10,11 @@
import type React from 'react'
import { useEffect, useRef, useState } from 'react'
import { api } from '@/api/client'
+import { useT } from '@/lib/i18n'
import { useApp } from '@/stores/app'
import { useAuth } from '@/stores/auth'
-import { useT } from '@/lib/i18n'
import { InvitePeopleModal } from './InvitePeopleModal'
+import { WorkspaceSettingsModal } from './WorkspaceSettingsModal'
export function CompanySwitcher() {
const t = useT()
@@ -28,6 +29,7 @@ export function CompanySwitcher() {
const [busy, setBusy] = useState(false)
const [err, setErr] = useState<string | null>(null)
const [inviteOpen, setInviteOpen] = useState(false)
+ const [settingsOpen, setSettingsOpen] = useState(false)
const popRef = useRef<HTMLDivElement | null>(null)
useEffect(() => {
@@ -122,17 +124,27 @@ export function CompanySwitcher() {
<div className="my-1 mx-2 h-px bg-ink-100" />
{active && (active.role === 'owner' || active.role === 'admin') && (
- <button
- type="button"
- onClick={() => { setInviteOpen(true); setOpen(false) }}
- className="w-full px-3 py-1.5 flex items-center gap-2 text-left hover:bg-cloud transition text-[12px] text-ink-700"
- >
- <span
- className="w-5 h-5 rounded grid place-items-center shrink-0 text-[11px]"
- style={{ background: 'var(--sky-50)', color: 'var(--skype)' }}
- >+</span>
- <span className="flex-1">{t('company.invitePeoplePrefix')}<b className="font-semibold">{active.name}</b></span>
- </button>
+ <>
+ <button
+ type="button"
+ onClick={() => { setSettingsOpen(true); setOpen(false) }}
+ className="w-full px-3 py-1.5 flex items-center gap-2 text-left hover:bg-cloud transition text-[12px] text-ink-700"
+ >
+ <span className="w-5 h-5 rounded grid place-items-center shrink-0 text-[11px]" style={{ background: 'var(--sky-50)', color: 'var(--skype)' }}>⚙</span>
+ <span className="flex-1">{t('company.workspaceSettings')}</span>
+ </button>
+ <button
+ type="button"
+ onClick={() => { setInviteOpen(true); setOpen(false) }}
+ className="w-full px-3 py-1.5 flex items-center gap-2 text-left hover:bg-cloud transition text-[12px] text-ink-700"
+ >
+ <span
+ className="w-5 h-5 rounded grid place-items-center shrink-0 text-[11px]"
+ style={{ background: 'var(--sky-50)', color: 'var(--skype)' }}
+ >+</span>
+ <span className="flex-1">{t('company.invitePeoplePrefix')}<b className="font-semibold">{active.name}</b></span>
+ </button>
+ </>
)}
{creating ? (
@@ -178,9 +190,18 @@ export function CompanySwitcher() {
<InvitePeopleModal
companyId={active.id}
companyName={active.name}
+ actorRole={active.role}
onClose={() => setInviteOpen(false)}
/>
)}
+ {settingsOpen && active && (
+ <WorkspaceSettingsModal
+ company={active}
+ companyCount={companies.length}
+ onInvite={() => { setSettingsOpen(false); setInviteOpen(true) }}
+ onClose={() => setSettingsOpen(false)}
+ />
+ )}
</div>
)
}
diff --git a/src/components/InvitePeopleModal.tsx b/src/components/InvitePeopleModal.tsx
index a67ce51..e1532d2 100644
--- a/src/components/InvitePeopleModal.tsx
+++ b/src/components/InvitePeopleModal.tsx
@@ -16,19 +16,20 @@
* regular members.
*/
import { useCallback, useEffect, useMemo, useState } from 'react'
-import { api, type ApiInvitation, type ApiInvitationWithToken } from '@/api/client'
-import { useAuth } from '@/stores/auth'
+import { type ApiInvitation, type ApiInvitationWithToken, api } from '@/api/client'
import { useT } from '@/lib/i18n'
+import { useAuth } from '@/stores/auth'
interface Props {
companyId: string
companyName: string
+ actorRole: string
onClose: () => void
}
type Tab = 'link' | 'email'
-export function InvitePeopleModal({ companyId, companyName, onClose }: Props) {
+export function InvitePeopleModal({ companyId, companyName, actorRole, onClose }: Props) {
const t = useT()
const [tab, setTab] = useState<Tab>('link')
const [list, setList] = useState<ApiInvitation[]>([])
@@ -202,7 +203,7 @@ export function InvitePeopleModal({ companyId, companyName, onClose }: Props) {
{t('invite.fieldRole')}
</label>
<div className="flex gap-1.5">
- {(['member', 'admin'] as const).map((r) => {
+ {(actorRole === 'owner' ? ['member', 'admin'] as const : ['member'] as const).map((r) => {
const on = role === r
return (
<button
diff --git a/src/components/NoWorkspaceScreen.tsx b/src/components/NoWorkspaceScreen.tsx
new file mode 100644
index 0000000..5b68299
--- /dev/null
+++ b/src/components/NoWorkspaceScreen.tsx
@@ -0,0 +1,56 @@
+import { useState } from 'react'
+import { api } from '@/api/client'
+import { useT } from '@/lib/i18n'
+import { useAuth } from '@/stores/auth'
+import { WindowDragStrip } from './WindowDragStrip'
+
+export function NoWorkspaceScreen() {
+ const t = useT()
+ const setMe = useAuth((s) => s.setMe)
+ const setServerCapabilities = useAuth((s) => s.setServerCapabilities)
+ const [name, setName] = useState('')
+ const [busy, setBusy] = useState(false)
+ const [error, setError] = useState<string | null>(null)
+
+ const create = async () => {
+ const trimmed = name.trim()
+ if (!trimmed || busy) return
+ setBusy(true); setError(null)
+ try {
+ await api.createCompany(trimmed)
+ const session = await api.authMe()
+ setMe(session.user, session.companies, session.activeCompanyId)
+ setServerCapabilities(session.serverCapabilities)
+ } catch (reason) {
+ setError(reason instanceof Error ? reason.message : String(reason))
+ } finally {
+ setBusy(false)
+ }
+ }
+
+ return (
+ <div className="fixed inset-0 grid place-items-center bg-cloud px-5">
+ <WindowDragStrip />
+ <div className="w-full max-w-[420px] rounded-[18px] border border-ink-100 bg-paper px-7 py-8 text-center shadow-xl">
+ <div className="mx-auto w-12 h-12 rounded-[13px] grid place-items-center bg-sky2-50 text-skype text-[22px] font-bold">+</div>
+ <h1 className="mt-4 text-[19px] font-semibold text-ink-900">{t('workspace.emptyTitle')}</h1>
+ <p className="mt-1.5 text-[12.5px] leading-relaxed text-ink-500">{t('workspace.emptyHelp')}</p>
+ <input
+ autoFocus
+ value={name}
+ onChange={(event) => setName(event.target.value)}
+ onKeyDown={(event) => { if (event.key === 'Enter') void create() }}
+ placeholder={t('company.workspaceNamePh')}
+ className="mt-5 w-full h-10 rounded-[9px] border border-ink-100 bg-paper px-3 text-[13px] outline-none focus:border-skype"
+ />
+ {error && <div className="mt-2 text-left text-[11.5px] text-coral-deep">{error}</div>}
+ <button
+ type="button"
+ onClick={() => void create()}
+ disabled={busy || !name.trim()}
+ className="mt-3 w-full h-10 rounded-[9px] bg-skype text-white text-[12.5px] font-semibold disabled:opacity-45"
+ >{busy ? '…' : t('workspace.emptyCreate')}</button>
+ </div>
+ </div>
+ )
+}
diff --git a/src/components/WorkspaceSessionBridge.tsx b/src/components/WorkspaceSessionBridge.tsx
new file mode 100644
index 0000000..3e6b287
--- /dev/null
+++ b/src/components/WorkspaceSessionBridge.tsx
@@ -0,0 +1,67 @@
+import { useEffect, useRef } from 'react'
+import { api, ws } from '@/api/client'
+import { useAuth } from '@/stores/auth'
+import { useConversations } from '@/stores/conversations'
+import { useParticipants } from '@/stores/participants'
+
+/** Keeps the auth company's list in sync when another owner/admin changes this
+ * user's role or removes/deletes a workspace. The server targets terminal
+ * removal frames directly, so this also works after membership is gone. */
+export function WorkspaceSessionBridge() {
+ const meId = useAuth((s) => s.user?.id ?? null)
+ const setMe = useAuth((s) => s.setMe)
+ const setServerCapabilities = useAuth((s) => s.setServerCapabilities)
+ const refreshing = useRef(false)
+ const refreshQueued = useRef(false)
+
+ useEffect(() => {
+ void ws.connect()
+
+ const refreshMembership = async () => {
+ if (refreshing.current) {
+ refreshQueued.current = true
+ return
+ }
+ refreshing.current = true
+ try {
+ do {
+ refreshQueued.current = false
+ try {
+ const session = await api.authMe()
+ // Snapshot immediately before committing. A local delete may have
+ // updated auth state while this request was in flight.
+ const before = useAuth.getState()
+ setMe(session.user, session.companies, session.activeCompanyId)
+ setServerCapabilities(session.serverCapabilities)
+ const after = useAuth.getState()
+ const beforeIds = before.companies.map((company) => company.id).sort().join('\n')
+ const afterIds = after.companies.map((company) => company.id).sort().join('\n')
+ if (before.activeCompanyId !== after.activeCompanyId || beforeIds !== afterIds) ws.reconnect()
+ } catch (error) {
+ console.warn('[workspace] failed to refresh membership state', error)
+ }
+ } while (refreshQueued.current)
+ } finally {
+ refreshing.current = false
+ }
+ }
+
+ return ws.on((event) => {
+ if (event.type !== 'workspace.membership' || !meId || !event.recipientUserIds.includes(meId)) return
+ if (event.kind === 'workspace_deleted' || event.userId === meId) {
+ void refreshMembership()
+ return
+ }
+ // A colleague was removed. The current user's auth state is unchanged,
+ // but participant and non-direct conversation rosters need reconciling.
+ if (event.kind === 'removed') {
+ void Promise.all([
+ useParticipants.getState().refresh(),
+ useConversations.getState().reload(),
+ ])
+ }
+ })
+ }, [meId, setMe, setServerCapabilities])
+
+ return null
+}
diff --git a/src/components/WorkspaceSettingsModal.tsx b/src/components/WorkspaceSettingsModal.tsx
new file mode 100644
index 0000000..c46423c
--- /dev/null
+++ b/src/components/WorkspaceSettingsModal.tsx
@@ -0,0 +1,217 @@
+import { useCallback, useEffect, useRef, useState } from 'react'
+import { type ApiWorkspaceMember, api, ws } from '@/api/client'
+import { useT } from '@/lib/i18n'
+import { type AuthCompany, useAuth } from '@/stores/auth'
+
+interface Props {
+ company: AuthCompany
+ companyCount: number
+ onInvite: () => void
+ onClose: () => void
+}
+
+export function WorkspaceSettingsModal({ company, companyCount, onInvite, onClose }: Props) {
+ const t = useT()
+ const meId = useAuth((s) => s.user?.id)
+ const removeCompany = useAuth((s) => s.removeCompany)
+ const [members, setMembers] = useState<ApiWorkspaceMember[]>([])
+ const [loading, setLoading] = useState(true)
+ const [error, setError] = useState<string | null>(null)
+ const [busyMemberId, setBusyMemberId] = useState<string | null>(null)
+ const [deleteConfirmation, setDeleteConfirmation] = useState('')
+ const [deleting, setDeleting] = useState(false)
+ const [deleteError, setDeleteError] = useState<string | null>(null)
+ const memberLoadGeneration = useRef(0)
+
+ useEffect(() => {
+ const onKey = (event: KeyboardEvent) => {
+ if (event.key === 'Escape' && !deleting) onClose()
+ }
+ window.addEventListener('keydown', onKey)
+ return () => window.removeEventListener('keydown', onKey)
+ }, [deleting, onClose])
+
+ const loadMembers = useCallback(async (showLoading: boolean) => {
+ const generation = ++memberLoadGeneration.current
+ if (showLoading) setLoading(true)
+ setError(null)
+ try {
+ const rows = await api.listWorkspaceMembers(company.id)
+ if (generation === memberLoadGeneration.current) setMembers(rows)
+ } catch (reason) {
+ if (generation === memberLoadGeneration.current) {
+ setError(reason instanceof Error ? reason.message : String(reason))
+ }
+ } finally {
+ if (generation === memberLoadGeneration.current) setLoading(false)
+ }
+ }, [company.id])
+
+ useEffect(() => {
+ void loadMembers(true)
+ return () => { memberLoadGeneration.current += 1 }
+ }, [loadMembers])
+
+ useEffect(() => ws.on((event) => {
+ if (event.type !== 'workspace.membership' || event.companyId !== company.id) return
+ void loadMembers(false)
+ }), [company.id, loadMembers])
+
+ const changeRole = async (member: ApiWorkspaceMember, role: 'member' | 'admin') => {
+ if (member.role === role) return
+ setBusyMemberId(member.id); setError(null)
+ try {
+ const result = await api.updateWorkspaceMemberRole(company.id, member.id, role)
+ setMembers((current) => current.map((row) => row.id === member.id ? result.member : row))
+ } catch (reason) {
+ setError(reason instanceof Error ? reason.message : String(reason))
+ } finally {
+ setBusyMemberId(null)
+ }
+ }
+
+ const removeMember = async (member: ApiWorkspaceMember) => {
+ if (!window.confirm(t('workspace.removeConfirm', { name: member.name }))) return
+ setBusyMemberId(member.id); setError(null)
+ try {
+ await api.removeWorkspaceMember(company.id, member.id)
+ setMembers((current) => current.filter((row) => row.id !== member.id))
+ } catch (reason) {
+ setError(reason instanceof Error ? reason.message : String(reason))
+ } finally {
+ setBusyMemberId(null)
+ }
+ }
+
+ const deleteWorkspace = async () => {
+ if (deleteConfirmation !== company.name || deleting || companyCount <= 1) return
+ setDeleting(true); setDeleteError(null)
+ try {
+ const result = await api.deleteCompany(company.id, deleteConfirmation)
+ if (removeCompany(company.id, result.nextCompanyId)) ws.reconnect()
+ onClose()
+ } catch (reason) {
+ setDeleteError(reason instanceof Error ? reason.message : String(reason))
+ } finally {
+ setDeleting(false)
+ }
+ }
+
+ return (
+ <div className="fixed inset-0 z-[120] grid place-items-center p-4" role="dialog" aria-modal="true" aria-label={t('workspace.settingsTitle')}>
+ <button
+ type="button"
+ className="absolute inset-0 bg-ink-900/35"
+ aria-label={t('common.close')}
+ disabled={deleting}
+ onClick={onClose}
+ />
+ <div className="relative w-full max-w-[620px] max-h-[86vh] overflow-y-auto rounded-[16px] bg-paper shadow-2xl border border-ink-100">
+ <div className="sticky top-0 z-10 flex items-start justify-between gap-4 px-5 py-4 bg-paper border-b border-ink-100">
+ <div className="min-w-0">
+ <h2 className="text-[17px] font-semibold text-ink-900">{t('workspace.settingsTitle')}</h2>
+ <div className="mt-0.5 text-[12px] text-ink-400 truncate">{company.name}</div>
+ </div>
+ <button
+ type="button"
+ disabled={deleting}
+ onClick={onClose}
+ className="w-8 h-8 rounded-full hover:bg-cloud text-ink-400 text-[20px] leading-none disabled:opacity-40"
+ >×</button>
+ </div>
+
+ <section className="px-5 py-4">
+ <div className="flex items-center justify-between gap-3 mb-3">
+ <div>
+ <h3 className="text-[13px] font-semibold text-ink-800">{t('workspace.membersTitle')}</h3>
+ <p className="text-[11.5px] text-ink-400 mt-0.5">{t('workspace.membersHelp')}</p>
+ </div>
+ <button type="button" onClick={onInvite} className="px-3 py-1.5 rounded-[8px] text-[12px] font-semibold text-white bg-skype hover:opacity-90">
+ {t('workspace.inviteBtn')}
+ </button>
+ </div>
+
+ {error && <div className="mb-3 rounded-[8px] bg-coral-soft/40 px-3 py-2 text-[11.5px] text-coral-deep">{error}</div>}
+ {loading ? (
+ <div className="py-7 text-center text-[12px] italic font-display text-ink-300">{t('workspace.loadingMembers')}</div>
+ ) : (
+ <div className="rounded-[10px] border border-ink-100 divide-y divide-ink-100 overflow-hidden">
+ {members.map((member) => {
+ const canChangeRole = company.role === 'owner' && member.role !== 'owner'
+ const canRemove = member.id !== meId && member.role !== 'owner'
+ && (company.role === 'owner' || (company.role === 'admin' && member.role === 'member'))
+ const busy = busyMemberId === member.id
+ return (
+ <div key={member.id} className="flex items-center gap-3 px-3 py-2.5 bg-paper">
+ <div className="w-9 h-9 rounded-full grid place-items-center shrink-0 text-[13px] font-semibold text-white overflow-hidden bg-skype">
+ {member.avatarUrl
+ ? <img src={member.avatarUrl} alt="" className="w-full h-full object-cover" />
+ : member.name.charAt(0).toUpperCase()}
+ </div>
+ <div className="min-w-0 flex-1">
+ <div className="flex items-center gap-1.5">
+ <span className="text-[12.5px] font-medium text-ink-900 truncate">{member.name}</span>
+ {member.id === meId && <span className="text-[10px] text-ink-300">{t('workspace.you')}</span>}
+ </div>
+ <div className="text-[10.5px] text-ink-400 truncate">{member.email}</div>
+ </div>
+ {canChangeRole ? (
+ <select
+ value={member.role}
+ disabled={busy}
+ onChange={(event) => void changeRole(member, event.target.value as 'member' | 'admin')}
+ className="h-8 rounded-[7px] border border-ink-100 bg-paper px-2 text-[11.5px] text-ink-700 disabled:opacity-50"
+ >
+ <option value="member">{t('workspace.roleMember')}</option>
+ <option value="admin">{t('workspace.roleAdmin')}</option>
+ </select>
+ ) : (
+ <span className="px-2 text-[10.5px] uppercase tracking-wide font-semibold text-ink-400">
+ {member.role === 'owner' ? t('workspace.roleOwner') : member.role === 'admin' ? t('workspace.roleAdmin') : t('workspace.roleMember')}
+ </span>
+ )}
+ {canRemove && (
+ <button
+ type="button"
+ disabled={busy}
+ onClick={() => void removeMember(member)}
+ className="px-2 py-1.5 rounded-[7px] text-[11px] font-medium text-coral-deep hover:bg-coral-soft/35 disabled:opacity-50"
+ >{busy ? '…' : t('workspace.removeBtn')}</button>
+ )}
+ </div>
+ )
+ })}
+ </div>
+ )}
+ </section>
+
+ {company.role === 'owner' && (
+ <section className="m-5 mt-1 rounded-[12px] border border-coral/35 bg-coral-soft/15 p-4">
+ <h3 className="text-[13px] font-semibold text-coral-deep">{t('workspace.dangerTitle')}</h3>
+ <p className="mt-1 text-[11.5px] leading-relaxed text-ink-500">
+ {companyCount <= 1 ? t('workspace.onlyWorkspace') : t('workspace.deleteHelp')}
+ </p>
+ <label className="block mt-3 text-[10.5px] font-semibold uppercase tracking-wide text-ink-400">
+ {t('workspace.typeName', { name: company.name })}
+ </label>
+ <div className="mt-1.5 flex gap-2">
+ <input
+ value={deleteConfirmation}
+ onChange={(event) => setDeleteConfirmation(event.target.value)}
+ disabled={deleting || companyCount <= 1}
+ className="min-w-0 flex-1 h-9 rounded-[8px] border border-ink-100 bg-paper px-3 text-[12px] outline-none focus:border-coral disabled:opacity-50"
+ />
+ <button
+ type="button"
+ onClick={() => void deleteWorkspace()}
+ disabled={deleting || companyCount <= 1 || deleteConfirmation !== company.name}
+ className="h-9 px-3 rounded-[8px] bg-coral-deep text-white text-[11.5px] font-semibold disabled:opacity-40"
+ >{deleting ? t('workspace.deleting') : t('workspace.deleteBtn')}</button>
+ </div>
+ {deleteError && <div className="mt-2 text-[11.5px] text-coral-deep">{deleteError}</div>}
+ </section>
+ )}
+ </div>
+ </div>
+ )
+}
diff --git a/src/locales/en.ts b/src/locales/en.ts
index 274205a..196216e 100644
--- a/src/locales/en.ts
+++ b/src/locales/en.ts
@@ -1486,6 +1486,27 @@ export const en = {
'company.createNew': 'Create new workspace',
'company.noWorkspace': 'no workspace',
'company.createBtn': 'Create',
+ 'company.workspaceSettings': 'Workspace settings',
+ 'workspace.settingsTitle': 'Workspace settings',
+ 'workspace.membersTitle': 'Members',
+ 'workspace.membersHelp': 'Manage who can access this workspace and what they can do.',
+ 'workspace.inviteBtn': 'Invite people',
+ 'workspace.loadingMembers': 'loading members…',
+ 'workspace.you': '(you)',
+ 'workspace.roleOwner': 'Owner',
+ 'workspace.roleAdmin': 'Admin',
+ 'workspace.roleMember': 'Member',
+ 'workspace.removeBtn': 'Remove',
+ 'workspace.removeConfirm': 'Remove {name} from this workspace? They will immediately lose access, but their message history will remain.',
+ 'workspace.dangerTitle': 'Delete workspace',
+ 'workspace.deleteHelp': 'Permanently deletes this workspace, including conversations, agents, documents, boards, calendar data, and attachments. This cannot be undone.',
+ 'workspace.onlyWorkspace': 'You cannot delete your only workspace. Create or join another workspace first.',
+ 'workspace.typeName': 'Type “{name}” to confirm',
+ 'workspace.deleteBtn': 'Delete workspace',
+ 'workspace.deleting': 'Deleting…',
+ 'workspace.emptyTitle': 'You are not in a workspace',
+ 'workspace.emptyHelp': 'You may have been removed from a previous workspace. Create a new one to continue.',
+ 'workspace.emptyCreate': 'Create workspace',
'dtpicker.prevMonth': 'Previous month',
'dtpicker.nextMonth': 'Next month',
'dtpicker.today': 'Today',
diff --git a/src/locales/zh-CN.ts b/src/locales/zh-CN.ts
index 2727d47..a5f29b0 100644
--- a/src/locales/zh-CN.ts
+++ b/src/locales/zh-CN.ts
@@ -1488,6 +1488,27 @@ export const zhCN: Partial<Record<keyof typeof en, string>> = {
'company.createNew': '创建新工作区',
'company.noWorkspace': '暂无工作区',
'company.createBtn': '创建',
+ 'company.workspaceSettings': '工作区设置',
+ 'workspace.settingsTitle': '工作区设置',
+ 'workspace.membersTitle': '成员',
+ 'workspace.membersHelp': '管理谁可以访问此工作区,以及他们可以执行的操作。',
+ 'workspace.inviteBtn': '邀请成员',
+ 'workspace.loadingMembers': '正在加载成员…',
+ 'workspace.you': '(你)',
+ 'workspace.roleOwner': '所有者',
+ 'workspace.roleAdmin': '管理员',
+ 'workspace.roleMember': '成员',
+ 'workspace.removeBtn': '移除',
+ 'workspace.removeConfirm': '确定将 {name} 移出此工作区吗?对方会立即失去访问权限,但历史消息会保留。',
+ 'workspace.dangerTitle': '删除工作区',
+ 'workspace.deleteHelp': '永久删除此工作区及其中的会话、智能体、文档、看板、日历数据和附件。此操作无法撤销。',
+ 'workspace.onlyWorkspace': '不能删除唯一的工作区。请先创建或加入另一个工作区。',
+ 'workspace.typeName': '输入“{name}”以确认',
+ 'workspace.deleteBtn': '删除工作区',
+ 'workspace.deleting': '正在删除…',
+ 'workspace.emptyTitle': '你当前不在任何工作区',
+ 'workspace.emptyHelp': '你可能已被移出之前的工作区。创建一个新工作区即可继续使用。',
+ 'workspace.emptyCreate': '创建工作区',
'dtpicker.prevMonth': '上个月',
'dtpicker.nextMonth': '下个月',
'dtpicker.today': '今天',
diff --git a/src/stores/auth.ts b/src/stores/auth.ts
index f93229c..95e9f72 100644
--- a/src/stores/auth.ts
+++ b/src/stores/auth.ts
@@ -44,6 +44,7 @@ interface AuthState {
setServerCapabilities: (caps: ServerCapabilities) => void
setActiveCompany: (id: string) => void
addCompany: (c: AuthCompany) => void
+ removeCompany: (id: string, nextCompanyId: string | null) => boolean
clear: () => void
markReady: () => void
}
@@ -51,6 +52,16 @@ interface AuthState {
const TOKEN_KEY = 'cumora.auth.token'
const COMPANY_KEY = 'cumora.auth.company'
+function resetWorkspaceStores(): void {
+ void Promise.all([
+ import('./documents').then(({ useDocuments }) => useDocuments.getState().reset()),
+ import('./boards').then(({ useBoards }) => useBoards.getState().reset()),
+ import('./calendar').then(({ useCalendar }) => useCalendar.getState().reset()),
+ import('./shipping').then(({ useShipping }) => useShipping.getState().reset()),
+ import('./app').then(({ useApp }) => useApp.getState().selectConversation(null)),
+ ])
+}
+
export const useAuth = create<AuthState>((set) => ({
token: localStorage.getItem(TOKEN_KEY),
user: null,
@@ -77,6 +88,8 @@ export const useAuth = create<AuthState>((set) => ({
? stored
: (activeCompanyId && memberIds.has(activeCompanyId) ? activeCompanyId : (companies[0]?.id ?? null))
if (resolved) localStorage.setItem(COMPANY_KEY, resolved)
+ else localStorage.removeItem(COMPANY_KEY)
+ const previous = useAuth.getState().activeCompanyId
set((s) => ({
user,
companies,
@@ -85,6 +98,7 @@ export const useAuth = create<AuthState>((set) => ({
? s.contextEpoch + 1
: s.contextEpoch,
}))
+ if (previous !== resolved) resetWorkspaceStores()
},
setServerCapabilities(caps) {
set({ serverCapabilities: caps })
@@ -103,12 +117,7 @@ export const useAuth = create<AuthState>((set) => ({
// next listXXX() lands. These stores are global singletons that
// outlive the AuthedApp remount, so a key-change alone doesn't
// clear them.
- void Promise.all([
- import('./documents').then(({ useDocuments }) => useDocuments.getState().reset()),
- import('./boards').then(({ useBoards }) => useBoards.getState().reset()),
- import('./calendar').then(({ useCalendar }) => useCalendar.getState().reset()),
- import('./shipping').then(({ useShipping }) => useShipping.getState().reset()),
- ])
+ resetWorkspaceStores()
},
/** Append a freshly-created company to the user's set and switch to it. */
addCompany(c) {
@@ -123,14 +132,30 @@ export const useAuth = create<AuthState>((set) => ({
// stores too so the new workspace doesn't render the previous
// one's data while the first listXXX() is in flight.
if (prevId && prevId !== c.id) {
- void Promise.all([
- import('./documents').then(({ useDocuments }) => useDocuments.getState().reset()),
- import('./boards').then(({ useBoards }) => useBoards.getState().reset()),
- import('./calendar').then(({ useCalendar }) => useCalendar.getState().reset()),
- import('./shipping').then(({ useShipping }) => useShipping.getState().reset()),
- ])
+ resetWorkspaceStores()
}
},
+ /** Apply the authoritative result of deleting a workspace immediately.
+ * The realtime bridge still reconciles with /auth/me, but no longer needs
+ * to duplicate the modal's fetch or socket reconnect. */
+ removeCompany(id, nextCompanyId) {
+ const current = useAuth.getState()
+ if (!current.companies.some((company) => company.id === id)) return false
+ const companies = current.companies.filter((company) => company.id !== id)
+ const memberIds = new Set(companies.map((company) => company.id))
+ const resolved = nextCompanyId && memberIds.has(nextCompanyId)
+ ? nextCompanyId
+ : (companies[0]?.id ?? null)
+ if (resolved) localStorage.setItem(COMPANY_KEY, resolved)
+ else localStorage.removeItem(COMPANY_KEY)
+ set((state) => ({
+ companies,
+ activeCompanyId: resolved,
+ contextEpoch: state.contextEpoch + 1,
+ }))
+ resetWorkspaceStores()
+ return true
+ },
clear() {
localStorage.removeItem(TOKEN_KEY)
localStorage.removeItem(COMPANY_KEY)
@@ -154,12 +179,7 @@ export const useAuth = create<AuthState>((set) => ({
// waiting for whoever signs in next on a shared machine.
void import('./app').then(({ useApp }) => useApp.getState().clearComposerDrafts())
// Library stores survive logout otherwise (they're global singletons).
- void Promise.all([
- import('./documents').then(({ useDocuments }) => useDocuments.getState().reset()),
- import('./boards').then(({ useBoards }) => useBoards.getState().reset()),
- import('./calendar').then(({ useCalendar }) => useCalendar.getState().reset()),
- import('./shipping').then(({ useShipping }) => useShipping.getState().reset()),
- ])
+ resetWorkspaceStores()
},
markReady() {
set({ ready: true })