dsh-device-fleet 0.1.0-dev.2 → 0.1.0-dev.20

package/src/plugin/index.js

@@ -4,7 +4,9 @@
 // the six `fleet_*` tools, and the two adoption mechanisms that are cheap to
 // land now (a prompt section and a first-use manual + orchestration nudge).
 // Room, Room Board, delegation and the UI land in later steps.
-import { readFileSync } from 'node:fs'
+import { mkdirSync, readFileSync } from 'node:fs'
+import { networkInterfaces } from 'node:os'
+import { join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { defineTool } from '@deepseek-ai/dsh-tools'
 import { createUserMessage } from '@deepseek-ai/dsh-llm'
@@ -12,10 +14,17 @@ import Schema from '@deepseek-ai/schemastery'
 import { FleetNode } from '../net/fleet-node.js'
 import { accountFingerprint } from '../net/identity.js'
 import { DirectCallClient, DirectCallHost } from '../host/direct-call.js'
+import { DelegationHost } from '../host/delegation.js'
+import { ApprovalInbox } from '../host/approval-inbox.js'
+import { RoomService } from '../host/room-service.js'
+import { registerApprovalRoutes } from '../host/approval-web.js'
+import { registerUiRoutes } from '../host/ui-web.js'
+import { registerConfigRoutes } from '../host/config-web.js'
+import { RuntimeConfig, deepMerge } from '../host/runtime-config.js'
 import { ExecutionSlot, DEFAULT_SHELL_TOOL } from '../host/execution-slot.js'
 import { ToolPolicy } from '../host/tool-policy.js'
 import { createFleetHandlers, createFleetToolDefinitions } from '../host/tools.js'
-import { accountMatches, createInvite, loadState, saveRoster, writePendingEnrollment } from '../host/store.js'
+import { accountMatches, createInvite, loadState, savePeerHint, saveRoster, writePendingEnrollment } from '../host/store.js'
 
 export const name = 'device-fleet'
 
@@ -59,9 +68,11 @@ export const Config = Schema.object({
     agentPreset: Schema.string(),
     shellTool: Schema.string().default(DEFAULT_SHELL_TOOL),
     approvalTimeoutMs: Schema.number().default(60000),
+    delegateTimeoutMs: Schema.number().default(180000),
+    subagentProvider: Schema.string().default('spawn'),
   })
-    .default({ shellTool: DEFAULT_SHELL_TOOL, approvalTimeoutMs: 60000 })
-    .description('Execution Slot: the hidden DSH session used to execute remote tool calls.'),
+    .default({ shellTool: DEFAULT_SHELL_TOOL, approvalTimeoutMs: 60000, delegateTimeoutMs: 180000, subagentProvider: 'spawn' })
+    .description('Execution Slot and delegation settings for direct calls and one-shot delegation.'),
   policy: Schema.object({
     allowedRoots: Schema.array(Schema.string()).default([]),
     capabilities: Schema.any().default({}),
@@ -72,6 +83,13 @@ export const Config = Schema.object({
     .description('Direct-call Tool Policy owned by this device (ADR-0004/ADR-0019).'),
   promptSection: Schema.boolean().default(true).description('Render the one-sentence Fleet nudge when the Fleet has members.'),
   autoApproveAsk: Schema.boolean().default(false).description('Testing only: auto-approve every local approval request.'),
+  approvals: Schema.object({
+    ttlMs: Schema.number().default(60000),
+    maxPending: Schema.number().default(50),
+    simulation: Schema.boolean().default(false),
+  })
+    .default({ ttlMs: 60000, maxPending: 50, simulation: false })
+    .description('Local approval inbox (ADR-0020). `simulation` exposes fleet_simulate_request for local testing.'),
 })
 
 function packageVersion() {
@@ -112,7 +130,7 @@ function withManual(definitions) {
   }))
 }
 
-export function apply(ctx, config) {
+export function apply(ctx, profileConfig) {
   const pluginVersion = packageVersion()
   const dshVersion = process.env.DSH_CLIENT_VERSION ?? 'unknown'
   // Optional services: Cordis throws on direct property access for services the
@@ -128,12 +146,30 @@ export function apply(ctx, config) {
 
   let state
   try {
-    state = loadState({ dshHome: process.env.DSH_HOME, dataDir: config.dataDir, name: config.deviceName })
+    state = loadState({ dshHome: process.env.DSH_HOME, dataDir: profileConfig?.dataDir, name: profileConfig?.deviceName })
   } catch (error) {
     logger.error?.(`[device-fleet] cannot load state: ${String(error?.message ?? error)}`)
     return
   }
 
+  // Runtime config: profile patch is the base, UI edits are persisted in the
+  // state dir and applied live (no plugin/DSH restart).
+  const runtime = new RuntimeConfig({
+    base: profileConfig ?? {},
+    overridesFile: join(state.dataDir, 'config-overrides.json'),
+  })
+  // Migration: an old UI save wrote the legacy `tool: deny` + empty allowlist;
+  // raw tools now follow the DSH pipeline by default.
+  if (
+    runtime.overrides?.policy?.capabilities?.tool === 'deny' &&
+    (runtime.overrides?.policy?.allowedTools?.length ?? 0) === 0
+  ) {
+    runtime.overrides = deepMerge(runtime.overrides, { policy: { capabilities: { tool: 'auto' } } })
+    runtime.current = deepMerge(runtime.base, runtime.overrides)
+    runtime.persist()
+  }
+  const config = runtime.current
+
   const node = new FleetNode({
     identity: state.identity,
     fleet: state.fleet,
@@ -143,6 +179,7 @@ export function apply(ctx, config) {
     discovery: config.discovery ? true : false,
     relay: config.relay ?? state.enrollment?.relay ?? null,
     roster: state.roster,
+    peerHints: [...(state.enrollment?.endpoints ?? []), ...(state.peerHints ?? [])],
     pluginVersion,
     dshVersion,
     capabilities: CAPABILITIES,
@@ -151,11 +188,198 @@ export function apply(ctx, config) {
   const policy = new ToolPolicy(config.policy)
   const sessionController = service('sessionController')
   const fs = service('fs')
+  const subagents = service('subagents')
+  const agentPresets = service('agentPresets')
+  const workingDirectory = service('workingDirectory')
+  const inbox = new ApprovalInbox({
+    ttlMs: config.approvals?.ttlMs ?? 60_000,
+    maxPending: config.approvals?.maxPending ?? 50,
+  })
+  inbox.on('request', (request) => logger.info?.(`[device-fleet] approval requested by ${request.fromDeviceId}: ${request.capability}/${String(request.tool ?? '')}`))
+  const approvalsApi = {
+    list: () => inbox.list(),
+    approve: (id, options) => inbox.approve(id, options),
+    deny: (id, reason) => inbox.deny(id, reason),
+    simulate: async ({ fromDeviceId, capability, tool, reason }) => {
+      if (runtime.current.approvals?.simulation !== true) {
+        throw Object.assign(new Error('approval simulation is disabled'), { code: 'unsupported' })
+      }
+      const promise = inbox.request({
+        fromDeviceId: fromDeviceId ?? 'simulated-device',
+        capability: capability ?? 'run',
+        tool: tool ?? null,
+        reason: reason ?? 'simulated approval request',
+        args: {},
+      })
+      const summary = inbox.list().at(-1)
+      // Keep the promise from becoming an unhandled rejection when the
+      // request expires without an answer; the demo only inspects the inbox.
+      promise.catch(() => {})
+      return `simulated approval request ${summary?.id ?? '?'} created; use fleet_approvals / fleet_approve / fleet_deny`
+    },
+  }
+  const requestApproval = async (request) =>
+    runtime.current.autoApproveAsk === true ? { approved: true, scope: 'once' } : inbox.request(request)
+
+  const rooms = new RoomService({
+    sessionController,
+    createUserMessage,
+    stateFile: join(state.dataDir, 'rooms.json'),
+  })
+
+  // Client approval panel data plane (dev.9). Optional service: host-only
+  // deployments simply do not expose the panel routes.
+  const webServer = service('webServer')
+  const workspaceDir = join(state.dataDir, 'workspace')
+  const getOptions = async () => {
+    const addresses = new Set(['0.0.0.0', '127.0.0.1', runtime.current.direct?.host ?? ''])
+    for (const entries of Object.values(networkInterfaces())) {
+      for (const entry of entries ?? []) {
+        if (entry.family === 'IPv4' && !entry.internal) addresses.add(entry.address)
+      }
+    }
+    addresses.delete('')
+    let toolNames = []
+    try {
+      toolNames = (ctx.tools.definitions?.() ?? []).map((definition) => definition.name)
+    } catch {
+      toolNames = []
+    }
+    const shellCandidates = ['pwsh', 'bash', 'cmd', 'sh']
+    let shells = shellCandidates.filter((name) => toolNames.includes(name))
+    if (shells.length === 0) shells = [process.platform === 'win32' ? 'pwsh' : 'bash']
+    let presets = []
+    try {
+      presets = (await agentPresets?.list?.()) ?? []
+    } catch {
+      presets = []
+    }
+    return {
+      platform: process.platform,
+      addresses: [...addresses],
+      shells,
+      subagentProviders: (() => {
+        try {
+          return subagents?.list?.() ?? ['spawn']
+        } catch {
+          return ['spawn']
+        }
+      })(),
+      tools: [...toolNames].sort(),
+      presets: presets.map((preset) => ({
+        id: preset.id ?? preset.name,
+        label: preset.name ?? preset.title ?? preset.id,
+      })),
+      cwd: {
+        workspace: workspaceDir,
+        dshHome: process.env.DSH_HOME ?? '',
+        defaultDirectory: workingDirectory?.defaultDirectory ?? '',
+        current: runtime.current.execution?.cwd ?? '',
+      },
+    }
+  }
+  let pairingRef = null
+  if (webServer) {
+    ctx.effect(() => registerApprovalRoutes({ webServer, inbox, logger }))
+    ctx.effect(() =>
+      registerConfigRoutes({
+        webServer,
+        runtime,
+        getOptions,
+        preparePatch: async (patch) => {
+          const cwd = patch?.execution?.cwd
+          if (typeof cwd === 'string' && cwd !== '') {
+            try {
+              mkdirSync(cwd, { recursive: true })
+            } catch (error) {
+              logger.warn?.(`[device-fleet] cannot create execution cwd: ${String(error?.message ?? error)}`)
+            }
+          }
+          return patch
+        },
+        logger,
+      }),
+    )
+    const uiActions = {
+      async sendRoomMessage({ roomId, to, text } = {}) {
+        if (typeof roomId !== 'string' || roomId === '') throw Object.assign(new Error('roomId is required'), { code: 'bad-request' })
+        const memberIds = rooms.status(roomId).members.map((member) => member.memberId)
+        const recipients = Array.isArray(to) && to.length > 0 ? to : memberIds.filter((id) => id.startsWith('host:'))
+        const result = await rooms.send({ roomId, from: { kind: 'user' }, to: recipients, text })
+        return { roomId, ...result }
+      },
+      async roomTask({ roomId, action, ...rest } = {}) {
+        if (typeof roomId !== 'string' || roomId === '') throw Object.assign(new Error('roomId is required'), { code: 'bad-request' })
+        if (action === 'add') {
+          return rooms.addTask({ roomId, title: rest.title, owner: rest.owner, dependsOn: rest.dependsOn ?? [], description: rest.description ?? '' })
+        }
+        if (action === 'update') {
+          return rooms.updateTask({ roomId, id: rest.id, status: rest.status, note: rest.note })
+        }
+        throw Object.assign(new Error('action must be add or update'), { code: 'bad-request' })
+      },
+      closeRoom: ({ roomId, reason } = {}) => rooms.close({ roomId, reason: reason ?? 'closed by user' }),
+      removeMember: ({ roomId, memberId, reason } = {}) => rooms.removeMember({ roomId, memberId, reason: reason ?? 'removed by user' }),
+      async upgradeRoom({ sessionId } = {}) {
+        if (typeof sessionId !== 'string' || sessionId === '') throw Object.assign(new Error('sessionId is required'), { code: 'bad-request' })
+        if (!sessionController?.resolveAgent) throw Object.assign(new Error('session agent is unavailable'), { code: 'unsupported' })
+        const resolved = await sessionController.resolveAgent(sessionId)
+        if (!resolved?.agent) throw Object.assign(new Error('session agent is unavailable'), { code: 'unsupported' })
+        return rooms.upgradeHost({ agent: resolved.agent })
+      },
+      createInvite: async () => {
+        if (!pairingRef?.invite) throw Object.assign(new Error('pairing is unavailable'), { code: 'unsupported' })
+        return pairingRef.invite()
+      },
+      connectAddress: async ({ host, port } = {}) => {
+        if (typeof host !== 'string' || !Number.isInteger(port) || port <= 0) {
+          throw Object.assign(new Error('host and port are required'), { code: 'bad-request' })
+        }
+        const peer = await node.connectAddress(host, port)
+        try {
+          savePeerHint(state, { host, port })
+        } catch {
+          /* best effort */
+        }
+        return { deviceId: peer.deviceId, name: peer.name ?? 'device' }
+      },
+    }
+    ctx.effect(() =>
+      registerUiRoutes({
+        webServer,
+        inbox,
+        rooms,
+        logger,
+        actions: uiActions,
+        getOverview: () => ({
+          ...(node.status?.() ?? {}),
+          rooms: rooms.list(),
+          approvals: inbox.list(),
+          approvalHistory: inbox.history?.() ?? [],
+        }),
+      }),
+    )
+  }
   if (!sessionController) logger.warn?.('[device-fleet] sessionController unavailable: direct calls to stateful tools will fail')
   const slot = sessionController
     ? new ExecutionSlot({ sessionController, tools: ctx.tools, config: config.execution })
     : null
 
+  const delegation =
+    slot && subagents
+      ? new DelegationHost({
+          subagents,
+          slot,
+          policy,
+          deviceId: state.identity.deviceId,
+          defaultCwd: config.execution?.cwd,
+          defaultAgentPreset: config.execution?.agentPreset,
+          provider: config.execution?.subagentProvider ?? 'spawn',
+          timeoutMs: config.execution?.delegateTimeoutMs ?? 180_000,
+          requestApproval,
+        })
+      : null
+
   const host = slot
     ? new DirectCallHost({
         slot,
@@ -168,15 +392,69 @@ export function apply(ctx, config) {
         capabilities: CAPABILITIES,
         shellTool: config.execution?.shellTool ?? DEFAULT_SHELL_TOOL,
         approvalTimeoutMs: config.execution?.approvalTimeoutMs ?? 60_000,
-        requestApproval: config.autoApproveAsk
-          ? async () => true
-          : async (request) => {
-              logger.info?.(`[device-fleet] approval required from ${request.fromDeviceId} for ${request.capability}/${String(request.tool)} (no approval UI yet)`)
-              return false
-            },
+        delegation,
+        requestApproval,
       })
     : null
 
+  // Mirror the normal DSH approval behavior for tools executed in the hidden
+  // Execution Slot: the tool pipeline asks here when its own pre-execute policy
+  // requires approval, and this device's approval inbox answers.
+  ctx.effect(() => {
+    if (!slot) return () => {}
+    const handler = async (request, next) => {
+      try {
+        if (request?.signal?.aborted) return 'cancelled'
+        if (!slot.sessionId || request?.agent?.session?.id !== slot.sessionId) return next()
+        const toolName = typeof request?.toolName === 'string' ? request.toolName : 'tool'
+        const outcome = await inbox.request({
+          fromDeviceId: 'local-tool-pipeline',
+          capability: 'tool',
+          tool: toolName,
+          reason: request?.displayReason ?? request?.reason ?? `tool "${toolName}" requires approval`,
+          args: {},
+        })
+        if (outcome.approved === true) return 'allowed-once'
+        if (outcome.reason === 'inbox-closed') return 'cancelled'
+        return 'rejected'
+      } catch {
+        return next()
+      }
+    }
+    return ctx.on('approval/request', handler)
+  })
+
+  // A Room is a normal Session whose user input is also delivered to its
+  // participants. Typing in the Host conversation therefore needs no separate
+  // Room composer.
+  ctx.effect(() =>
+    ctx.on?.('session/event', (session, event) => {
+      try {
+        if (!session?.id || event?.type !== 'user/message') return
+        const room = rooms.rooms.get(session.id)
+        if (!room) return
+        const message = event.data
+        if (message?.source?.kind && message.source.kind !== 'user') return
+        const text = (Array.isArray(message?.content) ? message.content : [])
+          .filter((block) => block?.type === 'text')
+          .map((block) => block.text)
+          .join('\n')
+          .trim()
+        if (text === '' || text.startsWith('[Room]') || text.startsWith('[Fleet Room')) return
+        const recipients = rooms
+          .status(session.id)
+          .members.filter((member) => member.role !== 'host')
+          .map((member) => member.memberId)
+        if (recipients.length === 0) return
+        void rooms.send({ roomId: session.id, from: { kind: 'user' }, to: recipients, text }).catch((error) => {
+          logger.warn?.(`[device-fleet] cannot broadcast room message: ${String(error?.message ?? error)}`)
+        })
+      } catch (error) {
+        logger.warn?.(`[device-fleet] room broadcast failed: ${String(error?.message ?? error)}`)
+      }
+    }),
+  )
+
   node.onRequest(async (request) => {
     if (!host) throw Object.assign(new Error('this device cannot serve direct calls (no execution slot)'), { code: 'unsupported' })
     return host.handleRequest(request)
@@ -213,6 +491,18 @@ export function apply(ctx, config) {
   }
 
   const client = new DirectCallClient({ node })
+  const localEndpoints = () => {
+    const port = node.directAddress?.port
+    if (!Number.isInteger(port) || port <= 0) return []
+    const endpoints = []
+    for (const entries of Object.values(networkInterfaces())) {
+      for (const entry of entries ?? []) {
+        if (entry.family !== 'IPv4' || entry.internal) continue
+        endpoints.push({ deviceId: state.identity.deviceId, host: entry.address, port })
+      }
+    }
+    return endpoints
+  }
   const pairing = {
     async invite() {
       const fingerprint =
@@ -221,27 +511,43 @@ export function apply(ctx, config) {
           : (state.enrollment?.accountFingerprint ?? null)
       return createInvite(state, {
         accountFingerprint: fingerprint,
-        relay: config.relay ?? state.enrollment?.relay ?? null,
+        relay: runtime.current.relay ?? state.enrollment?.relay ?? null,
+        endpoints: localEndpoints(),
       })
     },
     async join(code) {
       writePendingEnrollment(state, code)
     },
   }
-  const handlers = createFleetHandlers({ node, client, pairing })
+  pairingRef = pairing
+  const handlers = createFleetHandlers({
+    node,
+    client,
+    pairing,
+    onPeerHint: async (hint) => {
+      try {
+        savePeerHint(state, hint)
+      } catch (error) {
+        logger.warn?.(`[device-fleet] cannot persist peer hint: ${String(error?.message ?? error)}`)
+      }
+    },
+    approvals: approvalsApi,
+    rooms,
+  })
   const definitions = createFleetToolDefinitions({ defineTool, handlers })
   const wrapped = withManual(definitions.map((definition) => ({ ...definition, execute: safe(definition.execute) })))
   for (const definition of wrapped) ctx.tools.register(definition)
 
   // Adoption layer 2: one sentence, only when the Fleet has members.
   const systemPrompt = service('systemPrompt')
-  if (systemPrompt && config.promptSection !== false) {
+  if (systemPrompt) {
     const order = systemPrompt.getSectionOrder?.('TOOL_SUBAGENT') ?? PROMPT_SECTION_ORDER
     ctx.effect(() =>
       systemPrompt.section({
         name: 'device-fleet:members',
         order,
         text: () => {
+          if (runtime.current.promptSection === false) return ''
           const members = node.rosterEntries().length
           if (members === 0) return ''
           return `This DSH instance is part of a device Fleet with ${members} other device(s). Use fleet_list/fleet_read/fleet_fetch/fleet_run for work that belongs on another device; direct calls fail fast when that device is offline.`
@@ -250,6 +556,48 @@ export function apply(ctx, config) {
     )
   }
 
+  // Live config application: every UI save runs these handlers in-process.
+  runtime.onChange(async (next, previous) => {
+    if (JSON.stringify(next.policy) !== JSON.stringify(previous?.policy)) {
+      policy = new ToolPolicy(next.policy)
+      if (host) host.policy = policy
+      if (delegation) delegation.policy = policy
+    }
+    if (JSON.stringify(next.execution) !== JSON.stringify(previous?.execution)) {
+      slot?.setConfig(next.execution)
+      if (host) {
+        host.shellTool = next.execution?.shellTool ?? DEFAULT_SHELL_TOOL
+        host.approvalTimeoutMs = next.execution?.approvalTimeoutMs ?? 60_000
+      }
+      if (delegation) {
+        delegation.defaultCwd = next.execution?.cwd
+        delegation.defaultAgentPreset = next.execution?.agentPreset
+        delegation.provider = next.execution?.subagentProvider ?? 'spawn'
+        delegation.timeoutMs = next.execution?.delegateTimeoutMs ?? 180_000
+      }
+    }
+    if (JSON.stringify(next.approvals) !== JSON.stringify(previous?.approvals)) {
+      if (Number.isInteger(next.approvals?.ttlMs) && next.approvals.ttlMs >= 1000) inbox.ttlMs = next.approvals.ttlMs
+      if (Number.isInteger(next.approvals?.maxPending) && next.approvals.maxPending >= 1) inbox.maxPending = next.approvals.maxPending
+    }
+    if (next.deviceName !== previous?.deviceName) {
+      node.name = next.deviceName
+      if (host) host.name = next.deviceName
+    }
+    const networkChanged =
+      JSON.stringify(next.direct) !== JSON.stringify(previous?.direct) ||
+      next.discovery !== previous?.discovery ||
+      JSON.stringify(next.relay) !== JSON.stringify(previous?.relay)
+    if (networkChanged) {
+      await node.reconfigure({
+        name: next.deviceName,
+        direct: next.direct,
+        discovery: next.discovery ? true : false,
+        relay: next.relay ?? null,
+      })
+    }
+  })
+
   // Adoption layer 4: one-line nudge when the model starts orchestrating.
   ctx.on?.('tools/post-execute', async (exec, _result, next) => {
     const decision = await next()
@@ -277,6 +625,9 @@ export function apply(ctx, config) {
   })
 
   ctx.effect(() => () => {
+    inbox.close()
+    // Rooms are intentionally left open (and persisted) so a plugin reload can
+    // rehydrate them instead of destroying a running collaboration.
     void node.close()
   })