ds-bot 0.1.3 → 0.1.5

package/src/host/channel.js

@@ -40,7 +40,7 @@ export function install(rt) {
       ...bot, sessionId: rt.chatOf(bot.id), parts: (segments ?? []).map(segment => segment.sessionId), ...(kickoff ? { waiting: true } : {}),
     })),
     // `parts`: the members' hidden group Sessions and their earlier segments, for usage.
-    rooms: Object.values(state.rooms).map(({ log, seen, botRounds, sessions, segments, ...room }) => {
+    rooms: Object.values(state.rooms).map(({ log, seen, botRounds, lateRounds, sessions, segments, ...room }) => {
       const parts = [...Object.values(sessions ?? {}), ...Object.values(segments ?? {}).flat().map(segment => segment.sessionId)]
       const last = (log ?? []).filter(line => line.kind === undefined).at(-1)
       return { ...room, parts, ...(last ? { preview: last.who === 'User' ? last.text : `${last.who}：${last.text}` } : {}) }
@@ -51,6 +51,7 @@ export function install(rt) {
     agents: Object.values(state.agents),
     // Key names and who may use them; values never leave the host.
     secrets: rt.secretsView(),
+    capabilities: rt.capabilityLibraryView(),
     secretRequests: state.secretRequests ?? {},
     colors: [...COLORS, ...EXTRA_COLORS],
     models: rt.cachedCatalog(),
@@ -67,13 +68,15 @@ export function install(rt) {
   })
   // What changes without a new revision, sent with every state answer. `memoryNews`:
   // per Bot, its latest memory change; `memoryReviews`: memory reviews waiting or
-  // running; `work`: per Bot, the turn it runs and its tool, and the approvals waiting.
+  // running; `work`: per Bot, the turn it runs and its tool; per group, the members whose
+  // turn there runs; and the approvals waiting.
   const live = () => ({
     activity: rt.activityView(),
-    work: { bots: rt.workView(), approvals: rt.approvalsView() },
+    work: { bots: rt.workView(), rooms: rt.roomWorkView(), approvals: rt.approvalsView() },
     memoryNews: rt.memoryNews(),
     memoryReviews: rt.memoryReviews(),
     connectors: rt.connectorsView(),
+    capabilityStatuses: rt.capabilityStatusesView(),
   })
   // What a host that only reads the team may still answer.
   // Updates change the dsh profile, not the team, so a reading host may run them too.
@@ -97,7 +100,7 @@ export function install(rt) {
     return rt.save()
   }
 
-  const handle = async (endpoint, payload) => {
+  const handle = async (endpoint, payload, signal) => {
     try {
       const body = payload ?? {}
       await rt.refresh()
@@ -138,7 +141,7 @@ export function install(rt) {
           return ok([...rt.roomProgress.entries()].filter(([, entry]) => entry.roomId === body.roomId).map(([callId, entry]) => ({ callId, replies: entry.replies, speaking: entry.speaking ?? null })))
         case 'create-bot': {
           await rt.bootstrap()
-          const bot = await rt.createBot({ name: body.name, role: body.role, color: body.color, instructions: body.instructions, brief: body.brief, avatar: body.avatar, model: body.model, effort: body.effort })
+          const bot = await rt.createBot({ name: body.name, role: body.role, color: body.color, instructions: body.instructions, brief: body.brief, avatar: body.avatar, model: body.model, effort: body.effort, workDir: body.workDir })
           return ok(bot)
         }
         case 'update-bot':
@@ -171,9 +174,15 @@ export function install(rt) {
             members: Array.isArray(body.members) ? body.members : undefined,
             add: Array.isArray(body.add) ? body.add : undefined,
             remove: Array.isArray(body.remove) ? body.remove : undefined,
+            workDir: body.workDir,
           })
           return ok({ room: view().rooms.find(entry => entry.id === room.id), changes })
         }
+        case 'folders':
+        case 'folder-pick':
+        case 'folder-list':
+          await rt.load()
+          return ok(await rt.folderEndpoint(endpoint, body, signal))
         case 'add-agent':
           await rt.load()
           return ok(await rt.addAgent())
@@ -205,6 +214,8 @@ export function install(rt) {
         case 'approval-answer':
           rt.answerApproval(body.id, body.choice)
           return ok(true)
+        case 'stop-member-work':
+          return ok(await rt.stopMemberWork(String(body.roomId ?? ''), String(body.botId ?? '')))
         case 'dismiss-question':
           await rt.load()
           if (state.questions[body.sessionId] !== undefined) {
@@ -224,6 +235,12 @@ export function install(rt) {
         case 'connector-retry':
           await rt.load()
           return ok(await rt.connectorEndpoint(endpoint, body))
+        case 'capability-save':
+        case 'capability-delete':
+        case 'capability-approve':
+        case 'bot-capability':
+          await rt.load()
+          return ok(await rt.capabilityEndpoint(endpoint, body))
         case 'schedules':
         case 'schedule-create':
         case 'schedule-delete':
@@ -246,6 +263,7 @@ export function install(rt) {
           // Claim the question before queueing so a second answer is refused.
           delete state.questions[sessionId]
           try {
+            await rt.ensureCapabilities(sessionId)
             const agent = await rt.resolveAgent(sessionId)
             agent.followup(createUserMessage({ content: [{ type: 'text', text: reply.text }], source: reply.source }))
             await ctx.sessions.flush(agent.session)
@@ -263,6 +281,7 @@ export function install(rt) {
           // A Bot id or an earlier part of its own chat means the current part.
           const past = rt.pastOwners.get(body.sessionId)
           const sessionId = rt.botOf(body.sessionId) ? rt.chatOf(body.sessionId) : past && past.roomId === undefined ? rt.chatOf(past.botId) : body.sessionId
+          await rt.ensureCapabilities(sessionId)
           await ctx.sessionController.prompt({
             requestId: randomUUID(),
             sessionId,
@@ -319,7 +338,7 @@ export function install(rt) {
     fetch: async (request) => {
       let body
       try { body = await request.json() } catch { body = {} }
-      const result = await handle(String(body?.endpoint ?? ''), body?.payload)
+      const result = await handle(String(body?.endpoint ?? ''), body?.payload, request.signal)
       return new Response(JSON.stringify(result), { status: 200, headers: { 'content-type': 'application/json' } })
     },
   }), 'ds-bot: api route')

package/src/host/constants.js

@@ -21,6 +21,9 @@ export const OCR_CACHE_MAX = 500
 export const MAX_AVATAR_IMAGE = 160_000
 export const ROUTE = '/api/bot'
 export const MAX_HOPS = 6
+// Bot requests a Bot's own chat may hold unread; past this the Bot is most likely
+// stuck, and more messages only pile up behind it.
+export const MAX_UNREAD_REQUESTS = 10
 export const MAX_EXCHANGES = 600
 export const ROOM_REPLY_TIMEOUT_MS = 240_000
 export const SOURCE_KIND = 'bot'
@@ -49,9 +52,17 @@ export const TEAM_TOOLS = [
   'create_group', 'update_group', 'delete_group', 'post_to_group', 'ask_user',
   'request_secret', 'list_secrets', 'group_relay', 'read_own_chat',
   'read_group_chat', 'remember', 'forget', 'recall', 'read_browser',
+  'list_capabilities', 'save_capability', 'delete_capability',
+  'attach_capability', 'detach_capability',
 ]
 // Rounds Bots may start in one group by posting, before the user speaks there again.
 export const ROOM_BOT_ROUNDS = 3
+// Answers a group gives to what members post after the round moved on (their finished
+// work, mostly), before the user speaks there again.
+export const ROOM_LATE_ROUNDS = 10
+// A member still at work this long after its first tool call lets the round go on; it
+// posts its reply when the work is done.
+export const ROOM_WORK_GRACE_MS = 15_000
 
 export const OWN_CHAT_LINE_MAX = 400
 // The message an anchor points at is shown whole (up to this), so a long draft takes

package/src/host/delivery.js

@@ -9,11 +9,15 @@ export function install(rt) {
   const resolveAgent = async (sessionId) => {
     const resolved = await ctx.sessionController.resolveAgent(sessionId)
     if ('error' in resolved) throw new Error(resolved.error?.message ?? 'Session unavailable')
+    rt.hideBlockingQuestion(resolved.agent)
     return resolved.agent
   }
 
-  const headerFor = (role, fromName, roomName, audience, note = 'new message', deferred = false) => {
+  const headerFor = (role, fromName, roomName, audience, note = 'new message', deferred = false, { resumed = false, retried = false } = {}) => {
     if (deferred) return `[Message from ${fromName} · you read it during your last task; answer it now]`
+    if (retried && role !== 'room') return '[Your last reply wrote a tool call as text, so nothing ran]'
+    if (resumed && role === 'resume') return '[DeepSeek Harness restarted while you were working]'
+    if (resumed && role !== 'room') return `[Message from ${fromName} · DeepSeek Harness restarted while you were working on it]`
     if (role === 'reply') return `[Reply from ${fromName}]`
     if (role === 'stopped') return `[Stopped by ${fromName}]`
     if (role === 'room') return `[Group chat "${roomName}" · ${note}]`
@@ -29,8 +33,13 @@ export function install(rt) {
 
   // `sessionId` defaults to the recipient's own chat; group turns name its group Session.
   // `deferred`: a request the Bot already read mid-turn, handed back to answer in a
-  // turn of its own; its exchange was recorded when it first arrived.
-  async function deliver({ fromId, toId, sessionId, text, role, hop = 0, replyTo, roomId, audience, note, exchangeId = randomUUID(), steer = false, deferred = false }) {
+  // turn of its own; its exchange was recorded when it first arrived. `resumed` and
+  // `retried` carry on a turn that a restart cut off or that wrote its tool call as
+  // text (resume.js, turns.js), and `resent` is a message a shutdown cancelled; their
+  // exchange is recorded already too. `askedBy` is the member whose @mention called a
+  // group turn (groups.js). `fromRoomId`: the group whose Session the sender wrote
+  // from; the reply goes back to that Session (turns.js).
+  async function deliver({ fromId, toId, sessionId, text, role, hop = 0, replyTo, roomId, audience, note, exchangeId = randomUUID(), steer = false, deferred = false, resumed = false, retried = false, resent = false, askedBy, fromRoomId }) {
     const from = rt.botOf(fromId)
     const to = rt.botOf(toId)
     if (to === undefined) throw new Error(`Unknown Bot ${toId}`)
@@ -49,16 +58,22 @@ export function install(rt) {
       ...(roomId ? { roomId } : {}),
       ...(audience === 'user' ? { audience } : {}),
       ...(deferred ? { deferred: true } : {}),
+      ...(resumed ? { resumed: true } : {}),
+      ...(retried ? { retried: true } : {}),
+      ...(askedBy ? { askedBy } : {}),
+      ...(fromRoomId ? { senderRoomId: fromRoomId } : {}),
     }
-    if (EXCHANGE_ROLES.has(role) && !deferred) {
+    if (EXCHANGE_ROLES.has(role) && !deferred && !resumed && !retried && !resent) {
       state.exchanges.push({ id: exchangeId, from: fromId, to: toId, text, role, time: Date.now(), ...(replyTo ? { replyTo } : {}), ...(audience === 'user' ? { audience } : {}) })
       void rt.save().catch(() => {})
     }
-    const agent = await resolveAgent(sessionId ?? rt.chatOf(toId))
+    const targetSessionId = sessionId ?? rt.chatOf(toId)
+    await rt.ensureCapabilities(targetSessionId)
+    const agent = await resolveAgent(targetSessionId)
     // A steered message cuts into a running turn at its next step; a follow-up
     // queues for the next turn (see turns.js for how each is routed).
     const message = createUserMessage({
-      content: [{ type: 'text', text: `${headerFor(role, fromName, room?.name, audience, note, deferred)}\n${text}` }],
+      content: [{ type: 'text', text: `${headerFor(role, fromName, room?.name, audience, note, deferred, { resumed, retried })}\n${text}` }],
       source,
     })
     if (steer) agent.steer(message)

package/src/host/folders.js

@@ -0,0 +1,135 @@
+// Working folders: where a Bot's Sessions run. A group's folder holds for every member
+// there, else a Bot works in its own folder, else in the team workspace. A Session's
+// folder is fixed when it is made, so a change moves the conversation on to a fresh
+// part (parts.js).
+import { realpath, stat } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { basename, isAbsolute, join, resolve, sep } from 'node:path'
+import { unquote } from './text.js'
+
+const PICK_TIMEOUT_MS = 10 * 60_000
+
+export const within = (inner, outer) => inner === outer || inner.startsWith(outer.endsWith(sep) ? outer : outer + sep)
+
+const expandHome = text => (text === '~' ? homedir() : /^~[\\/]/.test(text) ? join(homedir(), text.slice(2)) : text)
+
+// Read as DSH reads it, so the team's data and the guarded folder are where DSH keeps
+// its own: a blank value counts as unset.
+export const dshHomeOf = value => resolve(expandHome(value?.trim() ? value : join(homedir(), '.dsh')))
+
+export function install(rt) {
+  const { ctx, state } = rt
+
+  const teamFolder = () => ctx.workspaceRegistry.get?.(state.workspaceId)?.path
+  const workDirOf = ({ botId, roomId } = {}) => rt.roomOf(roomId)?.workDir ?? rt.botOf(botId)?.workDir
+  const isFolder = path => stat(path).then(info => info.isDirectory(), () => false)
+  const real = path => realpath(path).catch(() => resolve(path))
+
+  // A Bot that could write where DSH or the team keeps its data could change its own
+  // permissions or the team, so neither those folders nor one that holds them is allowed.
+  async function guarded(path) {
+    const team = teamFolder()
+    for (const root of [rt.dshHome, rt.home]) {
+      const data = await real(root)
+      if (within(data, path)) return true
+      if (within(path, data) && !(team !== undefined && within(path, team))) return true
+    }
+    return false
+  }
+
+  // Saved as the real path, which is what a Session's cwd shows. Undefined means the
+  // team workspace.
+  async function cleanWorkDir(input) {
+    const text = unquote(input)
+    if (text === '') return undefined
+    const expanded = expandHome(text)
+    if (!isAbsolute(expanded)) throw new Error(`Give the full path of the folder, not ${text}`)
+    let path
+    try {
+      path = await realpath(expanded)
+    } catch {
+      throw new Error(`There is no folder at ${text}`)
+    }
+    if (!(await isFolder(path))) throw new Error(`${text} is a file, not a folder`)
+    if (await guarded(path)) throw new Error(`${path} holds DeepSeek Harness data, so Bots cannot work there`)
+    return path === teamFolder() ? undefined : path
+  }
+
+  // Every Session of a Bot: its own chat and its conversation in each of its groups.
+  const sessionsOfBot = botId => [rt.chatOf(botId), ...Object.values(state.rooms)
+    .filter(room => room.members.includes(botId)).map(room => room.sessions?.[botId])].filter(Boolean)
+
+  // A folder outside the team workspace widens where a Bot may write, so a Bot that
+  // sets one for Bots whose writes are bounded by their folder asks the user first.
+  // `sessions` are the Sessions that would work there; the default policy counts too,
+  // since the Sessions made there later start under it. Throws when it is not allowed.
+  async function approveFolder(exec, { path, sessions = [], who }) {
+    const team = teamFolder()
+    const policy = ctx.get?.('sandboxPolicy')
+    if (path === undefined || (team !== undefined && within(path, team)) || policy === undefined) return
+    const agents = await Promise.all(sessions.map(id => rt.resolveAgent(id)))
+    const modes = [policy.resolve(), ...agents.map(agent => policy.resolve({ session: agent.session }))].map(entry => entry.mode)
+    if (!modes.includes('workspace-write')) return
+    const approval = ctx.get?.('approval')
+    const agent = exec.agent
+    if (approval === undefined || agent?.session === undefined) throw new Error(`Working in ${path} needs the user's approval, and there is no way to ask for it here, so nothing changed. The user can make this change in the settings.`)
+    const outcome = await approval.request({
+      agent,
+      toolName: exec.name,
+      ...(exec.callId !== undefined ? { callId: exec.callId } : {}),
+      reason: `Let ${who.en} work in ${path}? Files there can then be changed.`,
+      displayReason: { en: `Let ${who.en} work in ${path}? Files there can then be changed.`, zh: `允许${who.zh}在 ${path} 中工作吗？之后可以修改这个文件夹里的文件。` },
+      ...(exec.signal ? { signal: exec.signal } : {}),
+    })
+    if (outcome === 'allowed-once') return
+    // An approval policy that never asks answers 'rejected' as well.
+    throw new Error(outcome === 'rejected' ? `Working in ${path} was not allowed, so nothing changed. The user can make this change in the settings.`
+      : outcome === 'cancelled' ? 'The approval was cancelled, so nothing changed.'
+        : `Working in ${path} needs the user's approval, and no one could answer, so nothing changed. The user can make this change in the settings.`)
+  }
+
+  const picker = () => {
+    try {
+      return ctx.get?.('directoryPicker')?.capability()
+    } catch {
+      return undefined
+    }
+  }
+
+  async function folderEndpoint(endpoint, body, signal) {
+    switch (endpoint) {
+      case 'folders': {
+        const team = teamFolder() ?? null
+        const known = new Map()
+        for (const workspace of ctx.workspaceRegistry.list?.() ?? []) {
+          if (workspace.path !== team) known.set(workspace.path, workspace.title)
+        }
+        for (const entry of [...Object.values(state.bots), ...Object.values(state.rooms)]) {
+          if (entry.workDir && !known.has(entry.workDir)) known.set(entry.workDir, basename(entry.workDir) || entry.workDir)
+        }
+        const present = await Promise.all([...known].map(async ([path, title]) => (await isFolder(path) ? { path, title } : undefined)))
+        const kind = picker()?.kind
+        return {
+          team,
+          picker: kind === 'native' || kind === 'browse' ? kind : null,
+          folders: present.filter(Boolean),
+        }
+      }
+      case 'folder-pick': {
+        const native = picker()
+        if (native?.kind !== 'native') throw new Error('This DeepSeek Harness has no folder chooser')
+        return await native.pick(AbortSignal.any([signal, AbortSignal.timeout(PICK_TIMEOUT_MS)].filter(Boolean)))
+      }
+      case 'folder-list': {
+        const browse = picker()
+        if (browse?.kind !== 'browse') throw new Error('This DeepSeek Harness cannot list folders')
+        const listing = await browse.list(typeof body.path === 'string' && body.path !== '' ? body.path : undefined, signal)
+        return { path: listing.path, home: listing.home, crumbs: listing.crumbs, entries: listing.entries, truncated: listing.truncated }
+      }
+      default:
+        throw new Error(`Unknown endpoint ${endpoint}`)
+    }
+  }
+
+  Object.assign(rt, { teamFolder, workDirOf, isFolder, cleanWorkDir, sessionsOfBot, approveFolder, folderEndpoint })
+}