Skip to content

A team of long-lived bots for DeepSeek Harness, with main bots, bot-to-bot messages and group chats.

Check a group change against the team as it is when it is written

Fei24119bcca2541ed4
diff --git a/ds-bot/src/host/roster.js b/ds-bot/src/host/roster.js
index 981bc34a..e88c8b8e 100644
--- a/ds-bot/src/host/roster.js
+++ b/ds-bot/src/host/roster.js
@@ -280,13 +280,15 @@ export function install(rt) {
if (members.length > ROOM_MAX_MEMBERS) throw new Error(`A group chat holds at most ${ROOM_MAX_MEMBERS} Bots`)
}
+ // A Main Bot leads the groups it makes; a group the user makes is led by a Main Bot
+ // member when it has one.
+ const defaultAdmin = (members, createdBy) => (members.includes(createdBy) ? createdBy : members.find(rt.isMain) ?? null)
+
async function createRoom({ members: memberIds = [], name: roomName, notice, mode, admin, createdBy } = {}) {
const members = [...new Set(memberIds)].filter(id => rt.botOf(id))
checkMembers(members)
const custom = cleanRoomName(roomName ?? '')
- // A Main Bot leads the groups it makes; a group the user makes is led by a Main
- // Bot member when it has one.
- const adminId = admin !== undefined ? admin : (members.includes(createdBy) ? createdBy : members.find(rt.isMain) ?? null)
+ const adminId = admin !== undefined ? admin : defaultAdmin(members, createdBy)
if (adminId !== null && !members.includes(adminId)) throw new Error('The admin must be a member of the group')
if (mode !== undefined && !ROOM_MODES.includes(mode)) throw new Error(`Reply mode must be one of ${ROOM_MODES.join(', ')}`)
const title = custom || autoRoomName(members)
@@ -294,19 +296,27 @@ export function install(rt) {
// group's folder is for its members' Sessions.
const id = await createSession(title)
try {
- state.rooms[id] = {
+ // A member deleted while the Session was made stays out, and the group is checked
+ // again as it is written.
+ const live = members.filter(member => rt.botOf(member))
+ checkMembers(live)
+ const lead = adminId === null || live.includes(adminId) ? adminId : defaultAdmin(live, createdBy)
+ const name = custom || autoRoomName(live)
+ const room = {
id,
- name: title,
+ name,
...(custom ? { named: true } : {}),
- members,
- admin: adminId,
+ members: live,
+ admin: lead,
mode: mode ?? 'admin',
notice: cleanNotice(notice),
createdAt: Date.now(),
createdBy: createdBy ?? null,
}
+ state.rooms[id] = room
await rt.save()
- return state.rooms[id]
+ if (name !== title) await retitleRoom(room)
+ return room
} catch (error) {
// The group's Session was already made: archive it instead of leaving an orphan.
delete state.rooms[id]
@@ -317,17 +327,20 @@ export function install(rt) {
}
}
- // `actorId` is the Bot asking, or undefined for the user. Returns what changed, in words.
- async function updateRoom(id, patch, actorId) {
- const room = rt.roomOf(id)
- if (room === undefined) throw new Error('Unknown group chat')
+ // What a change would write to the group as it is now, or why it cannot be made. It
+ // reads only the team, so updateRoom runs it to fail fast and again after its last
+ // await: another change or a deleted Bot may have come in meanwhile, and `add` and
+ // `remove` apply to the members the group has then.
+ function planRoomChange(room, patch, actorId) {
const byMain = actorId === undefined || rt.isMain(actorId)
const byAdmin = !byMain && rt.isAdminOf(room, actorId)
if (!byMain && !byAdmin) throw new Error(`Only the user, a Main Bot, or the admin of "${room.name}" can change it`)
let members = Array.isArray(patch.members) ? [...new Set(patch.members)] : [...room.members]
for (const member of patch.add ?? []) if (!members.includes(member)) members.push(member)
members = members.filter(member => !(patch.remove ?? []).includes(member) && rt.botOf(member))
- checkMembers(members)
+ // A group left with one Bot by a deletion can still change its other settings.
+ const current = room.members.filter(member => rt.botOf(member))
+ if (members.length !== current.length || members.some(member => !current.includes(member))) checkMembers(members)
let admin = room.admin ?? null
if (patch.admin !== undefined) {
admin = patch.admin || null
@@ -341,19 +354,32 @@ export function install(rt) {
if (patch.mode !== undefined && !ROOM_MODES.includes(patch.mode)) throw new Error(`Reply mode must be one of ${ROOM_MODES.join(', ')}`)
const name = patch.name === undefined ? undefined : cleanRoomName(patch.name, room.id)
const notice = patch.notice === undefined ? undefined : cleanNotice(patch.notice)
- const moving = patch.workDir !== undefined
- if (moving && byAdmin) throw new Error(`Only the user or a Main Bot can set the folder of "${room.name}"`)
- const workDir = moving ? await rt.cleanWorkDir(patch.workDir ?? '') : undefined
+ if (patch.workDir !== undefined && byAdmin) throw new Error(`Only the user or a Main Bot can set the folder of "${room.name}"`)
// A Bot's own permissions are the user's to set, so a group's are too.
if (patch.permission !== undefined && actorId !== undefined) throw new Error(`Only the user can set the permissions of "${room.name}"`)
const permission = patch.permission === undefined ? undefined : rt.cleanRoomPermission(patch.permission)
+ return { members, admin, name, notice, permission }
+ }
+
+ // `actorId` is the Bot asking, or undefined for the user. Returns what changed, in words.
+ async function updateRoom(id, patch, actorId) {
+ const asked = rt.roomOf(id)
+ if (asked === undefined) throw new Error('Unknown group chat')
+ planRoomChange(asked, patch, actorId)
+ const moving = patch.workDir !== undefined
+ const workDir = moving ? await rt.cleanWorkDir(patch.workDir ?? '') : undefined
+ // No await from here until every change is written.
+ const room = rt.roomOf(id)
+ if (room === undefined) throw new Error('Unknown group chat')
+ const { members, admin, name, notice, permission } = planRoomChange(room, patch, actorId)
const changes = []
const names = ids => ids.map(member => rt.botOf(member)?.name).filter(Boolean).join(', ')
const added = members.filter(member => !room.members.includes(member))
const removed = room.members.filter(member => !members.includes(member))
if (added.length > 0) changes.push(`added ${names(added)}`)
- if (removed.length > 0) changes.push(`removed ${names(removed)}`)
+ // A deleted Bot still listed goes without a word.
+ if (names(removed) !== '') changes.push(`removed ${names(removed)}`)
// A member who leaves and comes back starts from a fresh look at the log.
for (const member of removed) {
if (room.seen) delete room.seen[member]
@@ -376,9 +402,6 @@ export function install(rt) {
else room.workDir = workDir
changes.push(workDir ? `every member now works in ${workDir} here` : 'every member works in its own folder again')
}
- if (permission !== undefined && await rt.setRoomPermission(room, permission)) {
- changes.push(permission ? `every member now works with the ${permission} permissions here` : 'every member uses its own permissions again')
- }
const before = room.name
if (name !== undefined) {
if (name !== '') {
@@ -389,6 +412,10 @@ export function install(rt) {
}
}
if (!room.named) room.name = autoRoomName(room.members)
+ // The preset is written before its first await; the members' Sessions follow it.
+ if (permission !== undefined && await rt.setRoomPermission(room, permission)) {
+ changes.push(permission ? `every member now works with the ${permission} permissions here` : 'every member uses its own permissions again')
+ }
if (room.name !== before) {
changes.push(`renamed it "${room.name}"`)
await retitleRoom(room)
diff --git a/ds-bot/src/host/store.js b/ds-bot/src/host/store.js
index 580ce7ab..f80f3aba 100644
--- a/ds-bot/src/host/store.js
+++ b/ds-bot/src/host/store.js
@@ -160,6 +160,16 @@ export function install(rt) {
room.notice ??= ''
migrated = true
}
+ // A Bot deleted while a group was made or changed could stay listed in it, even as its
+ // admin; it leaves the group now.
+ for (const room of Object.values(state.rooms)) {
+ const members = room.members.filter(id => state.bots[id])
+ const admin = members.includes(room.admin) ? room.admin : null
+ if (members.length === room.members.length && admin === room.admin) continue
+ room.members = members
+ room.admin = admin
+ migrated = true
+ }
// Unnamed groups from before names followed their members may still list old names.
const stale = Object.values(state.rooms).filter(room => !room.named && room.name !== rt.autoRoomName(room.members))
for (const room of stale) room.name = rt.autoRoomName(room.members)
diff --git a/ds-bot/test/room-races.test.js b/ds-bot/test/room-races.test.js
new file mode 100644
index 00000000..46881a37
--- /dev/null
+++ b/ds-bot/test/room-races.test.js
@@ -0,0 +1,150 @@
+import assert from 'node:assert/strict'
+import { mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { test } from 'node:test'
+import { createRuntime } from '../index.js'
+import { fakeContext } from './fake-ctx.js'
+
+// #200, #205: a group change read the team, waited (for a Session or a folder check), and
+// then wrote what it had read. A Bot deleted, or another change made, in that wait was undone.
+const TEAM = {
+ version: 1,
+ mainBotIds: ['a'],
+ workspaceId: 'w1',
+ bots: {
+ a: { id: 'a', name: 'Chief', role: 'Boss', sessionId: 'a', createdAt: 1 },
+ b: { id: 'b', name: 'Writer', role: 'Write', sessionId: 'b', createdAt: 2 },
+ c: { id: 'c', name: 'Coder', role: 'Code', sessionId: 'c', createdAt: 3 },
+ d: { id: 'd', name: 'Tester', role: 'Test', sessionId: 'd', createdAt: 4 },
+ },
+ rooms: { r1: { id: 'r1', name: 'Ops', named: true, members: ['a', 'b'], admin: 'a', mode: 'admin', notice: '' } },
+ agents: {},
+ exchanges: [],
+ exchangeTurns: {},
+ questions: {},
+ prefs: {},
+ revision: 0,
+}
+
+async function start(team = TEAM) {
+ // The project folder sits beside the team's data, which no Bot may work in.
+ // The native realpath: on Windows the JS one keeps 8.3 short names.
+ const root = realpathSync.native(mkdtempSync(join(tmpdir(), 'ds-bot-room-races-')))
+ const home = join(root, 'bot')
+ const folder = join(root, 'project')
+ for (const dir of [home, folder]) mkdirSync(dir)
+ writeFileSync(join(home, 'state.json'), JSON.stringify(team))
+ const ctx = fakeContext()
+ const archived = []
+ let sessions = 0
+ // While `hold` is set, the next Session waits until it is let go.
+ let hold
+ Object.assign(ctx, {
+ llm: { listProviders: () => [], listModels: async () => [], resolveModelInfo: async () => ({}) },
+ workspaceRegistry: {
+ get: id => (id === 'w1' ? { id: 'w1', path: home } : undefined),
+ resolveByPath: async () => undefined,
+ create: async path => ({ id: 'w1', path }),
+ archiveSession: async (sessionId) => { archived.push(sessionId) },
+ },
+ sessionController: {
+ create: async () => {
+ const sessionId = `s${++sessions}`
+ if (hold !== undefined) await hold.promise
+ return { sessionId }
+ },
+ resolveAgent: async sessionId => ({ agent: { id: sessionId, session: { id: sessionId }, followup() {} } }),
+ selectModel: async () => {},
+ },
+ sessionTitle: { rename: async () => {} },
+ sessions: { flush: async () => {} },
+ })
+ const rt = createRuntime(ctx, { home })
+ await rt.load()
+ const held = () => {
+ let release
+ hold = { promise: new Promise(resolve => { release = resolve }) }
+ return () => { hold = undefined; release() }
+ }
+ const saved = () => JSON.parse(readFileSync(join(home, 'state.json'), 'utf8'))
+ const stop = async () => {
+ await ctx.dispose()
+ rmSync(root, { recursive: true, force: true, maxRetries: 5 })
+ }
+ return { rt, ctx, home, folder, archived, held, saved, stop }
+}
+
+test('a Bot deleted while its group is made stays out of it, and so does the admin role it was given', async (t) => {
+ const { rt, held, stop } = await start()
+ t.after(stop)
+ const release = held()
+ const making = rt.createRoom({ name: 'Trio', members: ['a', 'b', 'c'], admin: 'c' })
+ await rt.deleteBot('c')
+ release()
+ const room = await making
+ assert.deepEqual(room.members, ['a', 'b'])
+ // The lead goes to the Main Bot member, as for a group made without a chosen admin.
+ assert.equal(room.admin, 'a')
+})
+
+test('a group left with one Bot by a deletion while it is made is not made', async (t) => {
+ const { rt, held, archived, stop } = await start()
+ t.after(stop)
+ const release = held()
+ const making = rt.createRoom({ name: 'Pair', members: ['b', 'c'] })
+ await rt.deleteBot('c')
+ release()
+ await assert.rejects(making, /A group chat needs at least two Bots/)
+ assert.deepEqual(Object.keys(rt.state.rooms), ['r1'])
+ // Its Session was made already, so it is archived, not left over.
+ assert.ok(archived.includes('s1'))
+})
+
+test('a change that waits for its folder keeps the member another change added meanwhile', async (t) => {
+ const { rt, folder, saved, stop } = await start()
+ t.after(stop)
+ const moving = rt.updateRoom('r1', { add: ['c'], workDir: folder })
+ const adding = rt.updateRoom('r1', { add: ['d'] })
+ const [moved, added] = await Promise.all([moving, adding])
+ assert.deepEqual(added.changes, ['added Tester'])
+ assert.deepEqual(moved.changes, ['added Coder', `every member now works in ${folder} here`])
+ assert.deepEqual(saved().rooms.r1.members, ['a', 'b', 'd', 'c'])
+})
+
+test('a Bot deleted while a change waits for its folder is not added back', async (t) => {
+ const { rt, folder, saved, stop } = await start()
+ t.after(stop)
+ const moving = rt.updateRoom('r1', { add: ['c'], workDir: folder })
+ const deleting = rt.deleteBot('c')
+ const [moved] = await Promise.all([moving, deleting])
+ assert.deepEqual(moved.changes, [`every member now works in ${folder} here`])
+ assert.deepEqual(saved().rooms.r1.members, ['a', 'b'])
+})
+
+test('a group deleted while a change waits for its folder stays deleted', async (t) => {
+ const { rt, folder, saved, stop } = await start()
+ t.after(stop)
+ const refused = assert.rejects(rt.updateRoom('r1', { workDir: folder }), /Unknown group chat/)
+ await rt.deleteRoom('r1')
+ await refused
+ assert.deepEqual(saved().rooms, {})
+})
+
+test('a group left with one Bot can still change its settings, but not lose another member', async (t) => {
+ const { rt, stop } = await start()
+ t.after(stop)
+ await rt.deleteBot('b')
+ assert.deepEqual(rt.state.rooms.r1.members, ['a'])
+ assert.deepEqual((await rt.updateRoom('r1', { notice: 'Ship on Friday' })).changes, ['updated the notice'])
+ assert.deepEqual((await rt.updateRoom('r1', { add: ['c'] })).changes, ['added Coder'])
+ await assert.rejects(rt.updateRoom('r1', { remove: ['c'] }), /A group chat needs at least two Bots/)
+})
+
+test('a team saved with a deleted Bot in a group, even as its admin, loads without it', async (t) => {
+ const team = { ...TEAM, rooms: { r1: { ...TEAM.rooms.r1, members: ['a', 'b', 'gone'], admin: 'gone' } } }
+ const { rt, saved, stop } = await start(team)
+ t.after(stop)
+ assert.deepEqual([rt.state.rooms.r1.members, rt.state.rooms.r1.admin], [['a', 'b'], null])
+ assert.deepEqual([saved().rooms.r1.members, saved().rooms.r1.admin], [['a', 'b'], null])
+})