dsh-device-fleet 0.1.0-dev.3 → 0.1.0-dev.31

package/src/host/direct-call.js

@@ -27,6 +27,7 @@ export class DirectCallHost {
    * @param {string} [options.dshVersion]
    * @param {string[]} [options.capabilities]
    * @param {string} [options.shellTool]
+   * @param {object} [options.delegation] DelegationHost for `fleet.delegate`
    */
   constructor({
     slot,
@@ -40,6 +41,7 @@ export class DirectCallHost {
     capabilities = [],
     shellTool = DEFAULT_SHELL_TOOL,
     approvalTimeoutMs = DEFAULT_POLICY_TIMEOUT_MS,
+    delegation = null,
   }) {
     this.slot = slot
     this.policy = policy
@@ -52,6 +54,7 @@ export class DirectCallHost {
     this.capabilities = capabilities
     this.shellTool = shellTool
     this.approvalTimeoutMs = approvalTimeoutMs
+    this.delegation = delegation
   }
 
   info() {
@@ -75,6 +78,11 @@ export class DirectCallHost {
         return { deviceId: this.deviceId, tools: await this.slot.listTools(), policy: this.policy.summarize() }
       case 'fleet.call':
         return this.handleCall({ fromDeviceId: deviceId, request: params ?? {} })
+      case 'fleet.delegate':
+        if (!this.delegation) {
+          throw Object.assign(new Error('delegation is unavailable on this device'), { code: 'unsupported' })
+        }
+        return this.delegation.delegate({ fromDeviceId: deviceId, request: params ?? {} })
       default:
         throw Object.assign(new Error(`unknown fleet method: ${String(method)}`), { code: 'unknown-method' })
     }
@@ -89,9 +97,11 @@ export class DirectCallHost {
       throw Object.assign(new Error(decision.reason), { code: 'denied', data: { capability, tool } })
     }
     if (decision.decision === 'ask') {
-      const approved = await this.askApproval({ fromDeviceId, capability, tool, args, reason: decision.reason })
-      if (!approved) throw Object.assign(new Error('local approval was not granted'), { code: 'approval_denied' })
-      this.policy.grant(decision.key, { scope: 'once' })
+      const outcome = await this.askApproval({ fromDeviceId, capability, tool, args, reason: decision.reason })
+      if (outcome.approved !== true) {
+        throw Object.assign(new Error(outcome.reason ?? 'local approval was not granted'), { code: 'approval_denied' })
+      }
+      this.policy.grant(decision.key, { scope: outcome.scope === 'ttl' ? 'ttl' : 'once' })
     }
     const startedAt = Date.now()
     const result = await this.execute({ capability, tool, args })
@@ -108,12 +118,16 @@ export class DirectCallHost {
   }
 
   async askApproval({ fromDeviceId, capability, tool, args, reason }) {
-    if (typeof this.requestApproval !== 'function') return false
+    if (typeof this.requestApproval !== 'function') return { approved: false, reason: 'no approval channel' }
     try {
-      const approved = await this.requestApproval({ fromDeviceId, capability, tool, args, reason })
-      return approved === true
-    } catch {
-      return false
+      const outcome = await this.requestApproval({ fromDeviceId, capability, tool, args, reason })
+      if (outcome === true) return { approved: true, scope: 'once' }
+      if (outcome && typeof outcome === 'object') {
+        return { approved: outcome.approved === true, scope: outcome.scope ?? 'once', reason: outcome.reason }
+      }
+      return { approved: false, reason: 'approval not granted' }
+    } catch (error) {
+      return { approved: false, reason: String(error?.message ?? error) }
     }
   }
 
@@ -178,6 +192,11 @@ export class DirectCallClient {
     return this.node.request(deviceId, 'fleet.call', { capability, tool, args }, options)
   }
 
+  /** Ask the target device's agent to do a one-shot task and return its final text. */
+  async delegate(deviceId, request, options = {}) {
+    return this.node.request(deviceId, 'fleet.delegate', request, options)
+  }
+
   /** Format a remote result for a model-facing text tool. */
   render(result) {
     if (result?.isError) return `Error: ${result.text || 'remote tool failed'}`

package/src/host/execution-slot.js

@@ -18,6 +18,14 @@ export class ExecutionSlot {
     this.initializing = null
   }
 
+  /** Replace the slot's creation config; the next call lazily recreates the agent. */
+  setConfig(next = {}) {
+    this.config = { ...this.config, ...(next ?? {}) }
+    this.agent = null
+    this.sessionId = null
+    this.initializing = null
+  }
+
   async ensureAgent() {
     if (this.agent) return this.agent
     if (this.initializing) return this.initializing
@@ -55,11 +63,25 @@ export class ExecutionSlot {
    */
   async executeTool({ name, args = {}, signal }) {
     const agent = await this.ensureAgent()
-    const batch = await this.tools.execute({
-      calls: [{ id: randomUUID(), name, arguments: JSON.stringify(args ?? {}) }],
-      agent,
-      signal,
-    })
+    // execToolBatch requires a real AbortSignal: without one the pipeline
+    // throws before dispatch, which surfaces as "Tool batch execution failed".
+    const effectiveSignal = signal ?? new AbortController().signal
+    let batch
+    try {
+      batch = await this.tools.execute({
+        calls: [{ id: randomUUID(), name, arguments: JSON.stringify(args ?? {}) }],
+        agent,
+        signal: effectiveSignal,
+      })
+    } catch (error) {
+      const cause = error?.cause
+      const detail = cause?.message ?? error?.message ?? String(error)
+      throw Object.assign(new Error(`tool ${name} failed: ${String(detail)}`), {
+        code: 'tool-failed',
+        cause,
+        data: { causeCode: cause?.code ?? null, causeMessage: cause?.message ?? null },
+      })
+    }
     const first = batch?.results?.[0]?.result
     if (!first) throw Object.assign(new Error(`tool ${name} returned no result`), { code: 'tool-no-result' })
     const text = (first.content ?? [])

package/src/host/index.js

@@ -3,4 +3,12 @@ export * from './store.js'
 export * from './tool-policy.js'
 export * from './execution-slot.js'
 export * from './direct-call.js'
+export * from './delegation.js'
+export * from './approval-inbox.js'
+export * from './approval-web.js'
+export * from './ui-web.js'
+export * from './config-web.js'
+export * from './avatar-web.js'
+export * from './runtime-config.js'
+export * from './room-service.js'
 export * from './tools.js'

package/src/host/room-service.js

@@ -0,0 +1,435 @@
+// Room logic layer (ADR-0002/0005/0006/0011/0021), with local participants for
+// simulation inside one DSH. The Host session log carries the authoritative
+// room events; participant agents are real local DSH sessions woken with an
+// addressed message, so addressing/wake/visibility and board handoff can be
+// exercised before the remote transport and the client UI exist.
+import { randomUUID } from 'node:crypto'
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
+import { dirname } from 'node:path'
+
+const MAX_MESSAGE_CHARS = 20_000
+const STATE_VERSION = 1
+
+const DEFAULT_POLICY = Object.freeze({
+  invite: 'members',
+  join: 'auto',
+  maxMembers: 8,
+  boardWrite: 'members',
+  remove: 'members',
+})
+
+function hostMemberId(sessionId) {
+  return `host:${sessionId}`
+}
+
+function localMemberId(sessionId) {
+  return `local:${sessionId}`
+}
+
+export class RoomService {
+  /**
+   * @param {object} options
+   * @param {object} options.sessionController ctx.sessionController
+   * @param {(input: object) => object} [options.createUserMessage] dsh-llm helper
+   * @param {(now?: number) => number} [options.now]
+   * @param {string} [options.stateFile] JSON file used to rehydrate rooms after a reload
+   */
+  constructor({ sessionController, createUserMessage = null, now = Date.now, stateFile = null } = {}) {
+    this.sessionController = sessionController
+    this.createUserMessage = createUserMessage
+    this.now = now
+    this.stateFile = stateFile
+    /** @type {Map<string, any>} */
+    this.rooms = new Map()
+    if (stateFile) this.load()
+  }
+
+  /** Rehydrate active rooms from the persisted snapshot (agents resolve lazily). */
+  load() {
+    if (!this.stateFile || !existsSync(this.stateFile)) return
+    try {
+      const data = JSON.parse(readFileSync(this.stateFile, 'utf8'))
+      if (!data || data.version !== STATE_VERSION || !Array.isArray(data.rooms)) return
+      for (const stored of data.rooms) {
+        if (!stored || typeof stored.roomId !== 'string' || !Array.isArray(stored.members)) continue
+        const members = new Map()
+        for (const member of stored.members) {
+          if (!member || typeof member.memberId !== 'string') continue
+          members.set(member.memberId, { ...member, agent: undefined })
+        }
+        if (!members.has(hostMemberId(stored.roomId))) continue
+        this.rooms.set(stored.roomId, {
+          roomId: stored.roomId,
+          createdAt: Number.isFinite(stored.createdAt) ? stored.createdAt : this.now(),
+          hostSessionId: typeof stored.hostSessionId === 'string' ? stored.hostSessionId : stored.roomId,
+          policy: { ...DEFAULT_POLICY, ...(stored.policy ?? {}) },
+          members,
+          messages: Array.isArray(stored.messages) ? stored.messages : [],
+          tasks: new Map((Array.isArray(stored.tasks) ? stored.tasks : []).map((task) => [task.id, task])),
+          closed: false,
+        })
+      }
+    } catch {
+      /* a corrupt snapshot is ignored; the host session log stays authoritative */
+    }
+  }
+
+  persist() {
+    if (!this.stateFile) return
+    try {
+      const snapshot = {
+        version: STATE_VERSION,
+        savedAt: this.now(),
+        rooms: [...this.rooms.values()].map((room) => ({
+          roomId: room.roomId,
+          createdAt: room.createdAt,
+          hostSessionId: room.hostSessionId,
+          policy: room.policy,
+          members: [...room.members.values()].map(({ agent, ...rest }) => rest),
+          messages: room.messages,
+          tasks: [...room.tasks.values()],
+        })),
+      }
+      mkdirSync(dirname(this.stateFile), { recursive: true })
+      const temporary = `${this.stateFile}.tmp`
+      writeFileSync(temporary, JSON.stringify(snapshot, null, 2), 'utf8')
+      renameSync(temporary, this.stateFile)
+    } catch {
+      /* persistence is best effort; the session log remains authoritative */
+    }
+  }
+
+  /** Resolve a live agent for a persisted member on demand. */
+  async ensureAgent(member) {
+    if (member?.agent) return true
+    if (!member?.sessionId || !this.sessionController?.resolveAgent) return false
+    try {
+      const resolved = await this.sessionController.resolveAgent(member.sessionId)
+      if (!resolved?.agent) return false
+      member.agent = resolved.agent
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  async upgradeHost({ agent, policy = {} } = {}) {
+    if (!agent?.session?.id) throw Object.assign(new Error('room upgrade needs the calling agent session'), { code: 'bad-request' })
+    const sessionId = agent.session.id
+    const existing = this.rooms.get(sessionId)
+    if (existing) return this.summary(existing)
+    const memberId = hostMemberId(sessionId)
+    const room = {
+      roomId: sessionId,
+      createdAt: this.now(),
+      hostSessionId: sessionId,
+      policy: { ...DEFAULT_POLICY, ...policy },
+      members: new Map(),
+      messages: [],
+      tasks: new Map(),
+      closed: false,
+    }
+    room.members.set(memberId, {
+      memberId,
+      role: 'host',
+      kind: 'local',
+      sessionId,
+      name: agent.session.header?.title ?? 'host',
+      agent,
+    })
+    this.rooms.set(sessionId, room)
+    await this.append(room, 'room/created', { roomId: room.roomId, policy: room.policy, hostMemberId: memberId })
+    return this.summary(room)
+  }
+
+  async addLocalParticipant({ roomId, name = 'worker', agentPreset, cwd } = {}) {
+    const room = this.requireRoom(roomId)
+    if (room.members.size >= room.policy.maxMembers) {
+      throw Object.assign(new Error(`room member limit reached (${room.policy.maxMembers})`), { code: 'room-full' })
+    }
+    if (!this.sessionController?.create) {
+      throw Object.assign(new Error('participant sessions are unavailable'), { code: 'unsupported' })
+    }
+    const created = await this.sessionController.create({
+      ...(cwd ? { cwd } : {}),
+      ...(agentPreset ? { agentPreset } : {}),
+    })
+    const sessionId = created?.sessionId
+    if (!sessionId) throw Object.assign(new Error('could not create the participant session'), { code: 'room-participant-failed' })
+    const resolved = await this.sessionController.resolveAgent(sessionId)
+    if (!resolved?.agent) throw Object.assign(new Error('participant agent could not be resolved'), { code: 'room-participant-failed' })
+    const memberId = localMemberId(sessionId)
+    const member = { memberId, role: 'participant', kind: 'local', sessionId, name, agent: resolved.agent }
+    room.members.set(memberId, member)
+    await this.append(room, 'room/member', {
+      roomId: room.roomId,
+      action: 'added',
+      memberId,
+      role: 'participant',
+      name,
+      sessionId,
+    })
+    return this.memberSummary(member)
+  }
+
+  async removeMember({ roomId, memberId, reason = 'removed' } = {}) {
+    const room = this.requireRoom(roomId)
+    const member = room.members.get(memberId)
+    if (!member) throw Object.assign(new Error(`unknown member: ${String(memberId)}`), { code: 'unknown-member' })
+    if (member.role === 'host') throw Object.assign(new Error('the host cannot be removed; close the room instead'), { code: 'forbidden' })
+    room.members.delete(memberId)
+    await this.append(room, 'room/member', { roomId: room.roomId, action: 'removed', memberId, reason })
+    return { roomId: room.roomId, memberId }
+  }
+
+  /**
+   * Send one addressed message. The Host appends it to the canonical log and
+   * wakes only the addressed local members (never the sender).
+   */
+  async send({ roomId, from, to, text, skipWakeFor = [] } = {}) {
+    const room = this.requireRoom(roomId)
+    const body = typeof text === 'string' ? text.trim() : ''
+    if (body === '') throw Object.assign(new Error('room message needs text'), { code: 'bad-request' })
+    if (body.length > MAX_MESSAGE_CHARS) throw Object.assign(new Error('room message is too long'), { code: 'bad-request' })
+    const recipients = Array.isArray(to) ? to.filter((id) => typeof id === 'string') : []
+    if (recipients.length === 0) throw Object.assign(new Error('room message needs at least one recipient'), { code: 'bad-request' })
+    for (const memberId of recipients) {
+      if (!room.members.has(memberId)) throw Object.assign(new Error(`unknown member: ${memberId}`), { code: 'unknown-member' })
+    }
+    const sender = this.resolveSender(room, from)
+    const message = {
+      id: randomUUID(),
+      roomId: room.roomId,
+      from: sender,
+      to: recipients,
+      text: body,
+      createdAt: this.now(),
+    }
+    room.messages.push(message)
+    await this.append(room, 'room/message', {
+      roomId: room.roomId,
+      messageId: message.id,
+      from: sender,
+      to: recipients,
+      text: body,
+    })
+    const woken = []
+    for (const memberId of recipients) {
+      if (sender.memberId === memberId) continue
+      if (skipWakeFor.includes(memberId)) continue
+      const member = room.members.get(memberId)
+      if (await this.wake(room, member, message)) woken.push(memberId)
+    }
+    return { messageId: message.id, to: recipients, woken }
+  }
+
+  resolveSender(room, from) {
+    if (from && typeof from === 'object') {
+      if (typeof from.memberId === 'string') {
+        const member = room.members.get(from.memberId)
+        if (!member) throw Object.assign(new Error(`unknown sender member: ${from.memberId}`), { code: 'unknown-member' })
+        return { kind: 'agent', memberId: member.memberId, name: member.name ?? 'agent' }
+      }
+      if (typeof from.sessionId === 'string') {
+        for (const member of room.members.values()) {
+          if (member.sessionId === from.sessionId) {
+            return { kind: 'agent', memberId: member.memberId, name: member.name ?? 'agent' }
+          }
+        }
+        throw Object.assign(new Error(`sender session is not a room member: ${from.sessionId}`), { code: 'unknown-member' })
+      }
+      if (from.kind === 'user') return { kind: 'user', name: 'user' }
+    }
+    return { kind: 'user', name: 'user' }
+  }
+
+  /** Wake one local participant by injecting the addressed message. */
+  async wake(room, member, message) {
+    if (!member || typeof this.createUserMessage !== 'function') return false
+    if (!(await this.ensureAgent(member))) return false
+    if (typeof member.agent?.followup !== 'function') return false
+    // Participant replies are rendered by the Room view; do not inject them into
+    // the Host's normal Chat stream (that caused the host agent to relay them).
+    if (member.role === 'host' && message.from.kind !== 'user') return false
+    const senderLabel = message.from.kind === 'user' ? 'user' : (message.from.name ?? 'agent')
+    // A user sender has no member id; the reply target is always the Host member.
+    const replyTarget = message.from.memberId ?? hostMemberId(room.hostSessionId)
+    // The host is the user's own session: deliver a plain attributed line into
+    // the normal Chat stream instead of an agent-to-agent reply instruction.
+    const text =
+      member.role === 'host'
+        ? `[Room] ${senderLabel}: ${message.text}`
+        : [
+            `[Fleet Room ${room.roomId}] ${senderLabel} → you:`,
+            message.text,
+            '',
+            `Reply with room_send (roomId="${room.roomId}", to=["${replyTarget}"]) when you have an answer.`,
+          ].join('\n')
+    const userMessage = this.createUserMessage({ content: [{ type: 'text', text }], source: { kind: 'user' } })
+    try {
+      member.agent.followup(userMessage)
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  async append(room, type, data) {
+    const host = room.members.get(hostMemberId(room.hostSessionId))
+    const session = host?.agent?.session
+    if (session?.append) {
+      try {
+        await session.append(type, data)
+      } catch {
+        /* the snapshot below still records the room state */
+      }
+    }
+    this.persist()
+  }
+
+  // --------------------------------------------------------------- room tasks
+
+  async addTask({ roomId, title, owner, dependsOn = [], description = '' } = {}) {
+    const room = this.requireRoom(roomId)
+    if (typeof title !== 'string' || title.trim() === '') throw Object.assign(new Error('task needs a title'), { code: 'bad-request' })
+    const ownerMember = room.members.get(owner)
+    if (!ownerMember) throw Object.assign(new Error(`unknown task owner: ${String(owner)}`), { code: 'unknown-member' })
+    const id = randomUUID()
+    const task = {
+      id,
+      roomId: room.roomId,
+      title: title.trim(),
+      description,
+      owner,
+      status: 'pending',
+      dependsOn: Array.isArray(dependsOn) ? dependsOn : [],
+      readyNotified: false,
+      createdAt: this.now(),
+      updatedAt: this.now(),
+    }
+    room.tasks.set(id, task)
+    await this.append(room, 'room/task', { roomId: room.roomId, action: 'added', task })
+    return task
+  }
+
+  async updateTask({ roomId, id, status, note } = {}) {
+    const room = this.requireRoom(roomId)
+    const task = room.tasks.get(id)
+    if (!task) throw Object.assign(new Error(`unknown task: ${String(id)}`), { code: 'unknown-task' })
+    const allowed = ['pending', 'running', 'done', 'blocked']
+    if (status !== undefined && !allowed.includes(status)) {
+      throw Object.assign(new Error(`invalid task status: ${String(status)}`), { code: 'bad-request' })
+    }
+    if (status !== undefined) task.status = status
+    if (typeof note === 'string' && note !== '') task.note = note
+    task.updatedAt = this.now()
+    await this.append(room, 'room/task', { roomId: room.roomId, action: 'updated', task })
+    let handedOff = []
+    if (status === 'done') handedOff = await this.handOffReady(room)
+    return { task, handedOff }
+  }
+
+  /** Wake owners of pending tasks whose dependencies all completed. */
+  async handOffReady(room) {
+    const ready = []
+    for (const task of room.tasks.values()) {
+      if (task.status !== 'pending' || task.readyNotified) continue
+      if (task.dependsOn.length === 0) continue
+      const depsDone = task.dependsOn.every((dep) => room.tasks.get(dep)?.status === 'done')
+      if (!depsDone) continue
+      task.readyNotified = true
+      task.updatedAt = this.now()
+      const owner = room.members.get(task.owner)
+      const message = {
+        id: randomUUID(),
+        roomId: room.roomId,
+        from: { kind: 'user', name: 'room' },
+        to: [task.owner],
+        text: `任务 "${task.title}" 的前置任务已完成，现在可以开始。`,
+        createdAt: this.now(),
+      }
+      room.messages.push(message)
+      await this.append(room, 'room/message', { roomId: room.roomId, messageId: message.id, from: message.from, to: message.to, text: message.text })
+      const woken = owner ? await this.wake(room, owner, message) : false
+      ready.push({ taskId: task.id, owner: task.owner, woken })
+    }
+    return ready
+  }
+
+  listTasks(roomId) {
+    const room = this.requireRoom(roomId)
+    return [...room.tasks.values()].sort((a, b) => a.createdAt - b.createdAt)
+  }
+
+  // ------------------------------------------------------------------- reads
+
+  messages({ roomId, limit = 50 } = {}) {
+    const room = this.requireRoom(roomId)
+    const items = room.messages.slice(-Math.max(1, Math.min(limit, 200)))
+    return items.map((message) => ({
+      ...message,
+      fromLabel: message.from.kind === 'user' ? 'user' : `${message.from.name ?? 'agent'} (${message.from.memberId ?? '?'})`,
+    }))
+  }
+
+  summary(room) {
+    return {
+      roomId: room.roomId,
+      createdAt: room.createdAt,
+      closed: room.closed,
+      policy: { ...room.policy },
+      members: [...room.members.values()].map((member) => this.memberSummary(member)),
+      messageCount: room.messages.length,
+      tasks: this.listTasks(room.roomId).length,
+    }
+  }
+
+  memberSummary(member) {
+    return {
+      memberId: member.memberId,
+      role: member.role,
+      kind: member.kind,
+      sessionId: member.sessionId,
+      name: member.name,
+    }
+  }
+
+  status(roomId) {
+    return this.summary(this.requireRoom(roomId))
+  }
+
+  /** All active rooms (UI list). */
+  list() {
+    return [...this.rooms.values()].map((room) => this.summary(room))
+  }
+
+  /** One room plus its transcript and board (UI detail). */
+  detail(roomId, { limit = 100 } = {}) {
+    const room = this.requireRoom(roomId)
+    return {
+      ...this.summary(room),
+      messages: this.messages({ roomId, limit }),
+      tasks: this.listTasks(roomId),
+    }
+  }
+
+  /** All open rooms (for cleanup and diagnostics). */
+  openRooms() {
+    return [...this.rooms.keys()]
+  }
+
+  async close({ roomId, reason = 'closed by host' } = {}) {
+    const room = this.requireRoom(roomId)
+    room.closed = true
+    await this.append(room, 'room/closed', { roomId: room.roomId, reason, closedAt: this.now() })
+    this.rooms.delete(room.roomId)
+    this.persist()
+    return { roomId: room.roomId, closed: true, reason }
+  }
+
+  requireRoom(roomId) {
+    const room = this.rooms.get(roomId)
+    if (!room) throw Object.assign(new Error(`unknown or closed room: ${String(roomId)}`), { code: 'unknown-room' })
+    return room
+  }
+}