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.exampleindex 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.yamlindex 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_IMAGEvalue: "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_SECRETSdiff --git a/server/k8s/cumora-server.orbstack.yaml b/server/k8s/cumora-server.orbstack.yamlindex 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_NAMESPACEvalue: "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 thediff --git a/server/src/__integration__/_helpers.ts b/server/src/__integration__/_helpers.tsindex 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.tsnew file mode 100644index 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.tsindex 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 checksuassert.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.tsindex 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 : nullconst 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.tsindex 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').PoolClienawait 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.tsnew file mode 100644index 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.tsindex 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 = 3function assertManifestShape(): void {for (let i = 0; i < SCHEMA_MIGRATIONS.length; i++) {diff --git a/server/src/env.ts b/server/src/env.tsindex 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 afterdiff --git a/server/src/index.ts b/server/src/index.tsindex 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.tsindex 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+ | WorkspaceMembershipEventexport 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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.tsxindex 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.tsindex 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) => voiddiff --git a/src/components/CompanySwitcher.tsx b/src/components/CompanySwitcher.tsxindex 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() {<InvitePeopleModalcompanyId={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.tsxindex 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: stringcompanyName: string+ actorRole: stringonClose: () => 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 === rreturn (<buttondiff --git a/src/components/NoWorkspaceScreen.tsx b/src/components/NoWorkspaceScreen.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex f93229c..95e9f72 100644--- a/src/stores/auth.ts+++ b/src/stores/auth.ts@@ -44,6 +44,7 @@ interface AuthState {setServerCapabilities: (caps: ServerCapabilities) => voidsetActiveCompany: (id: string) => voidaddCompany: (c: AuthCompany) => void+ removeCompany: (id: string, nextCompanyId: string | null) => booleanclear: () => voidmarkReady: () => 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().activeCompanyIdset((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 })