ds-bot 0.1.1 → 0.1.3

package/index.js

@@ -12,9 +12,11 @@ import * as delivery from './src/host/delivery.js'
 import * as roster from './src/host/roster.js'
 import * as agents from './src/host/agents.js'
 import * as prompt from './src/host/prompt.js'
+import * as timeContext from './src/host/time-context.js'
 import * as tools from './src/host/tools.js'
 import * as chatIndex from './src/host/chat-index.js'
 import * as groups from './src/host/groups.js'
+import * as approvals from './src/host/approvals.js'
 import * as memory from './src/host/memory.js'
 import * as parts from './src/host/parts.js'
 import * as images from './src/host/images.js'
@@ -36,7 +38,7 @@ export const inject = ['llm', 'tools', 'systemPrompt', 'sessionController', 'ses
 // the functions other modules call; they call them through `rt` at run time, never during
 // install. Listeners run and tools are listed in registration order, so this order holds:
 // usage meters model requests after every listener that rewrites them.
-const MODULES = [diagnostics, store, models, permissions, turns, delivery, roster, agents, prompt, tools, chatIndex, groups, memory, parts, images, secrets, connectors, schedules, browser, usage, update, dshUpdate, channel]
+const MODULES = [diagnostics, store, models, permissions, turns, delivery, roster, agents, prompt, timeContext, tools, chatIndex, groups, approvals, memory, parts, images, secrets, connectors, schedules, browser, usage, update, dshUpdate, channel]
 
 export function apply(ctx, config = {}) {
   const home = config.home ?? join(process.env.DSH_HOME ?? join(homedir(), '.dsh'), 'bot')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ds-bot",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "DS Bot: a team of long-lived Bots for DeepSeek Harness, with Main Bots, Bot-to-Bot messages and group chats",
   "keywords": [
     "dsh-plugin",
@@ -11,13 +11,13 @@
     "multi-agent",
     "agents"
   ],
-  "homepage": "https://github.com/FeiZhuLulu/DeepSeek-Bot#readme",
+  "homepage": "https://github.com/Fei2411/DeepSeek-Bot#readme",
   "bugs": {
-    "url": "https://github.com/FeiZhuLulu/DeepSeek-Bot/issues"
+    "url": "https://github.com/Fei2411/DeepSeek-Bot/issues"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/FeiZhuLulu/DeepSeek-Bot.git",
+    "url": "git+https://github.com/Fei2411/DeepSeek-Bot.git",
     "directory": "ds-bot"
   },
   "license": "Apache-2.0",
@@ -32,6 +32,7 @@
   "files": [
     "index.js",
     "src/host/",
+    "src/shared/",
     "client.js",
     "web-search.js",
     "cordis.patch.yml",
@@ -42,6 +43,7 @@
     "build": "node scripts/build-client.mjs",
     "test": "node --import ./test/harness-resolve.mjs --test \"test/*.test.js\"",
     "lint": "node scripts/lint.mjs",
+    "harness": "npm install --prefix dev/harness --legacy-peer-deps=false --no-package-lock --no-fund --no-audit",
     "check": "sh dev/check.sh"
   },
   "peerDependencies": {
@@ -58,9 +60,6 @@
       "patch": "./cordis.patch.yml"
     }
   },
-  "dsBot": {
-    "verifiedDsh": "0.2.1-alpha.1"
-  },
   "devDependencies": {
     "esbuild": "0.28.2"
   }

package/src/host/approvals.js

@@ -0,0 +1,63 @@
+// Approvals. A member's group Session is hidden, so DSH's approval card never shows
+// there and the turn would wait forever: DS Bot answers those requests itself, from
+// the group chat. A Bot's own chat keeps DSH's card; its requests are only noted, so
+// the team view can say who is waiting.
+import { randomUUID } from 'node:crypto'
+
+const OUTCOMES = { allow: 'allowed-once', reject: 'rejected' }
+
+export function install(rt) {
+  const { ctx } = rt
+  /** @type {Map<string, {id:string, sessionId:string, botId:string, roomId?:string, tool:string, reason:string, detail:{text?:string, code?:string}, at:number, answer?:(outcome:string)=>void}>} */
+  const pending = new Map()
+
+  // Ahead of DSH's own answerer, which would hold a hidden Session's request unseen.
+  ctx.on('approval/request', (request, next) => {
+    const sessionId = request.agent?.session?.id ?? request.agent?.id
+    const owner = sessionId === undefined ? undefined : rt.groupOwners.get(sessionId)
+    const botId = owner?.botId ?? (sessionId === undefined ? undefined : rt.chatOwners.get(sessionId))
+    if (botId === undefined) return next()
+    const id = randomUUID()
+    const entry = {
+      id,
+      sessionId,
+      botId,
+      ...(owner ? { roomId: owner.roomId } : {}),
+      tool: String(request.toolName ?? ''),
+      reason: String(request.reason ?? '').slice(0, 500),
+      detail: rt.callDetail?.(sessionId, request.callId) ?? {},
+      at: Date.now(),
+    }
+    pending.set(id, entry)
+    if (owner === undefined) return Promise.resolve(next()).finally(() => pending.delete(id))
+    rt.yieldRoomTurn?.(sessionId)
+    return new Promise((resolve) => {
+      entry.answer = (outcome) => {
+        if (!pending.delete(id)) return
+        resolve(outcome)
+      }
+      if (request.signal?.aborted) entry.answer('cancelled')
+      request.signal?.addEventListener('abort', () => entry.answer('cancelled'), { once: true })
+    })
+  }, { prepend: true })
+
+  const approvalsView = () => [...pending.values()].map(({ answer, ...entry }) => ({ ...entry, answerable: answer !== undefined }))
+  const waitsForApproval = sessionId => [...pending.values()].some(entry => entry.sessionId === sessionId)
+
+  function answerApproval(id, choice) {
+    const entry = pending.get(String(id ?? ''))
+    if (entry?.answer === undefined) throw Object.assign(new Error('This approval is no longer open'), { code: 'bot/stale' })
+    const outcome = OUTCOMES[choice]
+    if (outcome === undefined) throw Object.assign(new Error('Choose allow or reject'), { code: 'bot/invalid' })
+    entry.answer(outcome)
+  }
+
+  // A group Session that leaves its group has no card left to answer from.
+  const cancelApprovals = (sessionId) => {
+    for (const entry of pending.values()) {
+      if (entry.sessionId === sessionId) entry.answer?.('cancelled')
+    }
+  }
+
+  Object.assign(rt, { approvalsView, waitsForApproval, answerApproval, cancelApprovals })
+}

package/src/host/channel.js

@@ -67,11 +67,17 @@ 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.
-  const live = () => ({ activity: rt.activityView(), memoryNews: rt.memoryNews(), memoryReviews: rt.memoryReviews(), connectors: rt.connectorsView() })
+  // running; `work`: per Bot, the turn it runs and its tool, and the approvals waiting.
+  const live = () => ({
+    activity: rt.activityView(),
+    work: { bots: rt.workView(), approvals: rt.approvalsView() },
+    memoryNews: rt.memoryNews(),
+    memoryReviews: rt.memoryReviews(),
+    connectors: rt.connectorsView(),
+  })
   // 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.
-  const READS = new Set(['state', 'models', 'efforts', 'earlier', 'room-progress', 'exchange', 'usage', 'schedules', 'memory-view', 'browser-wait', 'browser-result', 'diagnostics', 'diagnostics-log', 'diagnostics-clear', 'update-check', 'update-install', 'dsh-update-install'])
+  const READS = new Set(['state', 'models', 'efforts', 'earlier', 'room-progress', 'exchange', 'usage', 'schedules', 'memory-view', 'browser-wait', 'browser-result', 'diagnostics', 'diagnostics-log', 'diagnostics-clear', 'update-check', 'update-install', 'dsh-update-install', 'repo-stars', 'approval-answer'])
 
   function setPrefs(body) {
     if (body.theme !== undefined) {
@@ -196,6 +202,9 @@ export function install(rt) {
           await rt.load()
           await rt.deleteRoom(body.id)
           return ok(view())
+        case 'approval-answer':
+          rt.answerApproval(body.id, body.choice)
+          return ok(true)
         case 'dismiss-question':
           await rt.load()
           if (state.questions[body.sessionId] !== undefined) {
@@ -270,6 +279,8 @@ export function install(rt) {
           return ok(rt.updateStart())
         case 'dsh-update-install':
           return ok(rt.dshUpdateStart?.())
+        case 'repo-stars':
+          return ok(await rt.repoStars())
         // The Desktop window's long poll for read_browser, and its answers.
         case 'browser-wait': {
           if (rt.browserChannel === undefined) return fail('Bot browsers are off on this host', 'bot/browser-off')

package/src/host/constants.js

@@ -26,6 +26,9 @@ export const ROOM_REPLY_TIMEOUT_MS = 240_000
 export const SOURCE_KIND = 'bot'
 // An answer from a question card, in the shape DSH's own late question replies use.
 export const REPLY_KIND = 'user-question-reply'
+// DSH's snapshot of a referenced conversation, logged right after the user's message
+// that cites it.
+export const REFERENCE_KIND = 'session-reference'
 // `everyone`: every member answers a plain message in turn, admin first. `admin`: a
 // plain message goes to the admin, who calls others with @mentions. New groups start
 // in `admin` mode, because every extra speaker re-reads its whole context; a group
@@ -42,7 +45,7 @@ export const AGENT_SESSION_TITLE_MAX = 80
 // Every tool this plugin registers for Bots. `read_browser` only exists in the
 // Desktop profile, so a restriction filters this list down to registered names.
 export const TEAM_TOOLS = [
-  'list_bots', 'message_bot', 'create_bot', 'update_bot', 'list_models',
+  'list_bots', 'message_bot', 'stop_bot', 'create_bot', 'update_bot', 'list_models',
   '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',

package/src/host/delivery.js

@@ -12,8 +12,10 @@ export function install(rt) {
     return resolved.agent
   }
 
-  const headerFor = (role, fromName, roomName, audience, note = 'new message') => {
+  const headerFor = (role, fromName, roomName, audience, note = 'new message', deferred = false) => {
+    if (deferred) return `[Message from ${fromName} · you read it during your last task; answer it now]`
     if (role === 'reply') return `[Reply from ${fromName}]`
+    if (role === 'stopped') return `[Stopped by ${fromName}]`
     if (role === 'room') return `[Group chat "${roomName}" · ${note}]`
     if (role === 'report') return `[Group chat "${roomName}" · replies to your post]`
     if (role === 'kickoff') return '[Bot team setup]'
@@ -22,8 +24,13 @@ export function install(rt) {
     return `[Message from ${fromName}]`
   }
 
+  // Roles recorded as team exchanges.
+  const EXCHANGE_ROLES = new Set(['request', 'reply', 'stopped'])
+
   // `sessionId` defaults to the recipient's own chat; group turns name its group Session.
-  async function deliver({ fromId, toId, sessionId, text, role, hop = 0, replyTo, roomId, audience, note, exchangeId = randomUUID() }) {
+  // `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 }) {
     const from = rt.botOf(fromId)
     const to = rt.botOf(toId)
     if (to === undefined) throw new Error(`Unknown Bot ${toId}`)
@@ -41,16 +48,21 @@ export function install(rt) {
       ...(replyTo ? { replyTo } : {}),
       ...(roomId ? { roomId } : {}),
       ...(audience === 'user' ? { audience } : {}),
+      ...(deferred ? { deferred: true } : {}),
     }
-    if (role === 'request' || role === 'reply') {
+    if (EXCHANGE_ROLES.has(role) && !deferred) {
       state.exchanges.push({ id: exchangeId, from: fromId, to: toId, text, role, time: Date.now(), ...(replyTo ? { replyTo } : {}), ...(audience === 'user' ? { audience } : {}) })
-      void rt.save()
+      void rt.save().catch(() => {})
     }
     const agent = await resolveAgent(sessionId ?? rt.chatOf(toId))
-    agent.followup(createUserMessage({
-      content: [{ type: 'text', text: `${headerFor(role, fromName, room?.name, audience, note)}\n${text}` }],
+    // 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}` }],
       source,
-    }))
+    })
+    if (steer) agent.steer(message)
+    else agent.followup(message)
     await ctx.sessions.flush(agent.session)
     return exchangeId
   }

package/src/host/diagnostics.js

@@ -16,7 +16,7 @@ const LOG_MAX_BYTES = 1 << 20
 const STACK_LINES = 8
 const TEXT_MAX = 2000
 export const REPORT_ENTRIES = 20
-export const ISSUES_URL = 'https://github.com/FeiZhuLulu/DeepSeek-Bot/issues/new'
+export const ISSUES_URL = 'https://github.com/Fei2411/DeepSeek-Bot/issues/new'
 
 const quote = value => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 
@@ -144,7 +144,7 @@ export function install(rt) {
     }).catch((error) => {
       if (fileFailed) return
       fileFailed = true
-      console.error('[ds-bot] diagnostics log not written:', error?.code ?? error?.message ?? error)
+      console.error('[ds-bot] diagnostics log not written:', error?.code ?? clean(error?.message ?? String(error)))
     })
   }
 
@@ -164,13 +164,15 @@ export function install(rt) {
   }
 
   const warn = (template, ...args) => {
-    ctx.logger.warn(template, ...args)
-    console.error(`[ds-bot] ${template}`, ...args.map(arg => arg?.stack ?? arg))
     const error = args.find(arg => arg instanceof Error)
+    const line = clean(format(template, ...args.map(arg => (arg instanceof Error ? errorText(arg) : arg))))
+    const frames = typeof error?.stack === 'string' ? error.stack.split('\n').filter(item => /^\s+at /.test(item)).slice(0, STACK_LINES).map(item => item.trim()) : []
+    ctx.logger.warn('%s', line)
+    console.error(`[ds-bot] ${line}${frames.length > 0 ? `\n${clean(frames.join('\n'))}` : ''}`)
     note({
       level: 'warn',
       source: 'host',
-      text: format(template, ...args.map(arg => (arg instanceof Error ? errorText(arg) : arg))).replace(/^ds-bot: /, ''),
+      text: line.replace(/^ds-bot: /, ''),
       code: typeof error?.code === 'string' ? error.code : undefined,
       stack: error?.stack,
     })

package/src/host/dsh-update.js

@@ -1,9 +1,11 @@
-// DSH updates: every released DS Bot names the DSH release it was verified
-// against (`dsBot.verifiedDsh` in package.json). The newest released bot wins:
-// offering that version and nothing newer keeps the update path away from DSH
-// releases we have not checked. A DSH installed from npm swaps with
-// `npm i -g`; a packaged app's runtime lives inside its bundle, so the card
-// there only reports current and verified — its own updater chooses versions.
+// DSH updates: a released DS Bot may name the DSH release it was verified
+// against (`dsBot.verifiedDsh` in package.json); a release that names none
+// offers nothing. The newest released bot wins: offering that version and
+// nothing newer keeps the update path away from DSH releases we have not
+// checked. A DSH installed from npm swaps with `npm i -g`; a packaged app's
+// runtime lives inside its bundle and only its own updater moves it, to the
+// newest release it finds, so the client offers it only when that release is
+// the verified one.
 import { spawn } from 'node:child_process'
 import { readFileSync } from 'node:fs'
 import { dirname, join } from 'node:path'