dsh-device-fleet 0.1.0-dev.1 → 0.1.0-dev.11

package/src/plugin/index.js

@@ -5,17 +5,22 @@
 // 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 { networkInterfaces } from 'node:os'
 import { fileURLToPath } from 'node:url'
 import { defineTool } from '@deepseek-ai/dsh-tools'
 import { createUserMessage } from '@deepseek-ai/dsh-llm'
-import { Schema } from '@deepseek-ai/schemastery'
+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 { 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 +64,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 +79,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() {
@@ -115,7 +129,16 @@ function withManual(definitions) {
 export function apply(ctx, config) {
   const pluginVersion = packageVersion()
   const dshVersion = process.env.DSH_CLIENT_VERSION ?? 'unknown'
-  const logger = ctx.logger ?? console
+  // Optional services: Cordis throws on direct property access for services the
+  // plugin did not inject, so every optional service goes through get().
+  const service = (name) => {
+    try {
+      return ctx.get?.(name)
+    } catch {
+      return undefined
+    }
+  }
+  const logger = service('logger') ?? console
 
   let state
   try {
@@ -134,19 +157,74 @@ 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,
   })
 
   const policy = new ToolPolicy(config.policy)
-  const sessionController = ctx.sessionController ?? ctx.get?.('sessionController')
-  const fs = ctx.fs ?? ctx.get?.('fs')
+  const sessionController = service('sessionController')
+  const fs = service('fs')
+  const subagents = service('subagents')
+  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: config.approvals?.simulation
+      ? async ({ fromDeviceId, capability, tool, reason }) => {
+          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`
+        }
+      : null,
+  }
+  const requestApproval = config.autoApproveAsk
+    ? async () => ({ approved: true, scope: 'once' })
+    : async (request) => inbox.request(request)
+
+  const rooms = new RoomService({ sessionController, createUserMessage })
+
+  // Client approval panel data plane (dev.9). Optional service: host-only
+  // deployments simply do not expose the panel routes.
+  const webServer = service('webServer')
+  if (webServer) {
+    ctx.effect(() => registerApprovalRoutes({ webServer, inbox, logger }))
+  }
   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,
@@ -159,12 +237,8 @@ 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
 
@@ -186,7 +260,7 @@ export function apply(ctx, config) {
   })
 
   // Bind the local account fingerprint when the account service is composed.
-  const account = ctx.get?.('deepseekAccount')
+  const account = service('deepseekAccount')
   if (account && typeof account.getDeviceIdentity === 'function') {
     void account
       .getDeviceIdentity()
@@ -204,6 +278,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 =
@@ -213,19 +299,33 @@ export function apply(ctx, config) {
       return createInvite(state, {
         accountFingerprint: fingerprint,
         relay: config.relay ?? state.enrollment?.relay ?? null,
+        endpoints: localEndpoints(),
       })
     },
     async join(code) {
       writePendingEnrollment(state, code)
     },
   }
-  const handlers = createFleetHandlers({ node, client, 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 = ctx.get?.('systemPrompt') ?? ctx.systemPrompt
+  const systemPrompt = service('systemPrompt')
   if (systemPrompt && config.promptSection !== false) {
     const order = systemPrompt.getSectionOrder?.('TOOL_SUBAGENT') ?? PROMPT_SECTION_ORDER
     ctx.effect(() =>
@@ -268,9 +368,13 @@ export function apply(ctx, config) {
   })
 
   ctx.effect(() => () => {
+    inbox.close()
+    for (const roomId of rooms.openRooms()) {
+      void rooms.close({ roomId, reason: 'plugin unloaded' }).catch(() => {})
+    }
     void node.close()
   })
 
-  ctx.logger?.info?.(`[device-fleet] v${pluginVersion} device ${state.identity.deviceId} (${config.deviceName})`)
+  logger.info?.(`[device-fleet] v${pluginVersion} device ${state.identity.deviceId} (${config.deviceName})`)
   void ready
 }