dsh-device-fleet 0.0.0-stage → 0.1.0-dev.10

package/src/host/store.js

@@ -0,0 +1,156 @@
+// Persistent device state for the fleet plugin: identity, fleet, roster, config.
+// Everything lives under `$DSH_HOME/device-fleet/` (or DEVICE_FLEET_DATA_DIR).
+import fs from 'node:fs'
+import path from 'node:path'
+import { createFleet, decodeInvite, encodeInvite, generateIdentity } from '../net/identity.js'
+
+export function resolveDataDir({ dshHome, override } = {}) {
+  if (override) return path.resolve(override)
+  if (process.env.DEVICE_FLEET_DATA_DIR) return path.resolve(process.env.DEVICE_FLEET_DATA_DIR)
+  const home = dshHome ?? process.env.DSH_HOME ?? process.cwd()
+  return path.join(home, 'device-fleet')
+}
+
+function readJson(file, fallback) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'))
+  } catch {
+    return fallback
+  }
+}
+
+function writeJsonAtomic(file, value) {
+  fs.mkdirSync(path.dirname(file), { recursive: true })
+  const tmp = `${file}.tmp-${process.pid}-${Date.now()}`
+  fs.writeFileSync(tmp, JSON.stringify(value, null, 2))
+  fs.renameSync(tmp, file)
+}
+
+/**
+ * Load or create the persistent device state.
+ * @returns {{dataDir: string, identity: object, fleet: object, roster: object[], config: object, enrollment: object|null, createdFleet: boolean}}
+ */
+export function loadState({ dshHome, dataDir, name = 'device' } = {}) {
+  const dir = resolveDataDir({ dshHome, override: dataDir })
+  fs.mkdirSync(dir, { recursive: true })
+
+  let identity = readJson(path.join(dir, 'identity.json'), null)
+  if (!identity) {
+    identity = generateIdentity({ name })
+    writeJsonAtomic(path.join(dir, 'identity.json'), identity)
+  }
+
+  let createdFleet = false
+  let fleet = readJson(path.join(dir, 'fleet.json'), null)
+  if (!fleet) {
+    fleet = createFleet({ name: `${name} fleet` })
+    writeJsonAtomic(path.join(dir, 'fleet.json'), fleet)
+    createdFleet = true
+  }
+
+  const roster = readJson(path.join(dir, 'roster.json'), [])
+  const config = readJson(path.join(dir, 'config.json'), {})
+  const peerHints = readJson(path.join(dir, 'peer-hints.json'), [])
+  let enrollment = readJson(path.join(dir, 'enrollment.json'), null)
+  let pendingEnrollment = readJson(path.join(dir, 'enrollment.pending.json'), null)
+
+  // A pending invite written by `fleet_join` takes effect on the next load:
+  // enrolling while the network node is already running would leave the two
+  // sides on different fleets.
+  if (pendingEnrollment?.code) {
+    try {
+      const decoded = decodeInvite(pendingEnrollment.code)
+      fleet = decoded.fleet
+      enrollment = {
+        joinedAt: Date.now(),
+        accountFingerprint: decoded.accountFingerprint ?? null,
+        relay: decoded.relay ?? null,
+        endpoints: decoded.endpoints ?? [],
+      }
+      writeJsonAtomic(path.join(dir, 'fleet.json'), fleet)
+      writeJsonAtomic(path.join(dir, 'enrollment.json'), enrollment)
+      fs.unlinkSync(path.join(dir, 'enrollment.pending.json'))
+      pendingEnrollment = null
+    } catch {
+      // Keep the pending file; the user can fix the invite and restart again.
+    }
+  }
+
+  return {
+    dataDir: dir,
+    identity,
+    fleet,
+    roster: Array.isArray(roster) ? roster : [],
+    config,
+    enrollment,
+    pendingEnrollment,
+    peerHints: Array.isArray(peerHints) ? peerHints : [],
+    createdFleet,
+  }
+}
+
+/** Persist one manually supplied peer address (from fleet_connect) for reconnects. */
+export function savePeerHint(state, hint) {
+  if (!hint || typeof hint.host !== 'string' || !Number.isInteger(hint.port) || hint.port <= 0) return
+  const entry = {
+    host: hint.host,
+    port: hint.port,
+    ...(typeof hint.deviceId === 'string' ? { deviceId: hint.deviceId } : {}),
+  }
+  const hints = Array.isArray(state.peerHints) ? state.peerHints : []
+  const exists = hints.some((item) => item.host === entry.host && item.port === entry.port && item.deviceId === entry.deviceId)
+  if (!exists) hints.push(entry)
+  state.peerHints = hints
+  writeJsonAtomic(path.join(state.dataDir, 'peer-hints.json'), hints)
+}
+
+/** Queue an invite for the next plugin load (the running node keeps its fleet). */
+export function writePendingEnrollment(state, code) {
+  decodeInvite(code) // validate before writing
+  writeJsonAtomic(path.join(state.dataDir, 'enrollment.pending.json'), { code, queuedAt: Date.now() })
+}
+
+export function saveIdentity(state) {
+  writeJsonAtomic(path.join(state.dataDir, 'identity.json'), state.identity)
+}
+
+export function saveFleet(state) {
+  writeJsonAtomic(path.join(state.dataDir, 'fleet.json'), state.fleet)
+}
+
+export function saveRoster(state, roster) {
+  state.roster = roster
+  writeJsonAtomic(path.join(state.dataDir, 'roster.json'), roster)
+}
+
+export function saveConfig(state, config) {
+  state.config = config
+  writeJsonAtomic(path.join(state.dataDir, 'config.json'), config)
+}
+
+/** Create an invite for this device's fleet. */
+export function createInvite(state, { accountFingerprint = null, relay = null, endpoints = [] } = {}) {
+  return encodeInvite({ fleet: state.fleet, accountFingerprint, relay, endpoints })
+}
+
+/** Join a fleet from an invite code (overwrites fleet/enrollment, keeps identity). */
+export function enrollFromInvite(state, code) {
+  const decoded = decodeInvite(code)
+  state.fleet = decoded.fleet
+  state.enrollment = {
+    joinedAt: Date.now(),
+    accountFingerprint: decoded.accountFingerprint ?? null,
+    relay: decoded.relay ?? null,
+    endpoints: decoded.endpoints ?? [],
+  }
+  saveFleet(state)
+  writeJsonAtomic(path.join(state.dataDir, 'enrollment.json'), state.enrollment)
+  return state.enrollment
+}
+
+/** Check a locally observed account fingerprint against the invite's binding. */
+export function accountMatches(state, fingerprint) {
+  const expected = state.enrollment?.accountFingerprint ?? null
+  if (!expected) return true // unbound invite: accept the first account and caller may bind
+  return fingerprint !== null && fingerprint === expected
+}

package/src/host/tool-policy.js

@@ -0,0 +1,151 @@
+// Target-device tool policy (ADR-0004, ADR-0019, ADR-0020).
+// The policy owns: allowed roots, per-capability mode (auto/ask/deny),
+// the raw-tool allowlist, and short-lived grants created by approvals.
+import path from 'node:path'
+
+export const CAPABILITIES = ['read', 'list', 'grep', 'fetch', 'run', 'tool', 'delegate']
+
+export const DEFAULT_POLICY = Object.freeze({
+  allowedRoots: [],
+  capabilities: {
+    read: 'auto',
+    list: 'auto',
+    grep: 'auto',
+    fetch: 'auto',
+    run: 'ask',
+    tool: 'deny',
+    delegate: 'ask',
+  },
+  allowedTools: [],
+  approvalTtlMs: 15 * 60 * 1000,
+})
+
+/** True when `candidate` resolves inside one of `roots`. */
+export function pathWithinRoots(roots, candidate) {
+  const resolved = path.resolve(String(candidate))
+  return roots.some((root) => {
+    const base = path.resolve(String(root))
+    const relative = path.relative(base, resolved)
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative))
+  })
+}
+
+export class ToolPolicy {
+  constructor(config = {}) {
+    this.config = normalizeConfig(config)
+    /** @type {Map<string, {expiresAt: number, remaining: number}>} */
+    this.grants = new Map()
+  }
+
+  get roots() {
+    return this.config.allowedRoots
+  }
+
+  summarize() {
+    return {
+      allowedRoots: this.roots,
+      capabilities: { ...this.config.capabilities },
+      allowedTools: [...this.config.allowedTools],
+    }
+  }
+
+  /** Decide one call: { decision: 'allow' | 'ask' | 'deny', reason, key } */
+  decide({ capability, tool = null, args = {} } = {}) {
+    const capabilityName = CAPABILITIES.includes(capability) ? capability : 'tool'
+    const mode = this.config.capabilities[capabilityName] ?? 'deny'
+    const grantKey = `${capabilityName}:${capabilityName === 'tool' ? String(tool) : '*'}`
+    if (this.consumeGrant(grantKey)) return { decision: 'allow', reason: 'approved grant', key: grantKey, capability: capabilityName }
+
+    const paths = collectPaths(args)
+    const needsRoots = ['read', 'list', 'grep', 'fetch'].includes(capabilityName)
+    if (needsRoots) {
+      if (this.roots.length === 0) {
+        return { decision: 'deny', reason: 'no allowed roots configured on this device', key: grantKey, capability: capabilityName }
+      }
+      for (const candidate of paths) {
+        if (!pathWithinRoots(this.roots, candidate)) {
+          return {
+            decision: 'deny',
+            reason: `path is outside the allowed roots: ${String(candidate)}`,
+            key: grantKey,
+            capability: capabilityName,
+          }
+        }
+      }
+    }
+    if (capabilityName === 'run' && this.config.capabilities.run === 'allow') {
+      return { decision: 'allow', reason: 'run is allowed by policy', key: grantKey, capability: capabilityName }
+    }
+    if (capabilityName === 'tool') {
+      if (!this.config.allowedTools.includes(String(tool))) {
+        return {
+          decision: 'deny',
+          reason: `tool ${String(tool)} is not in the allowed tools list`,
+          key: grantKey,
+          capability: capabilityName,
+        }
+      }
+      return { decision: 'allow', reason: 'tool is allowlisted', key: grantKey, capability: capabilityName }
+    }
+    if (mode === 'allow') return { decision: 'allow', reason: 'capability is allowed by policy', key: grantKey, capability: capabilityName }
+    if (mode === 'auto') return { decision: 'allow', reason: 'capability is auto-approved', key: grantKey, capability: capabilityName }
+    if (mode === 'ask') return { decision: 'ask', reason: 'capability requires local approval', key: grantKey, capability: capabilityName }
+    return { decision: 'deny', reason: 'capability is disabled by policy', key: grantKey, capability: capabilityName }
+  }
+
+  /** Remember an approval as a expiring grant (TTL scope) or allow one call (once scope). */
+  grant(key, { scope = 'once', ttlMs = this.config.approvalTtlMs, now = Date.now() } = {}) {
+    if (typeof key !== 'string' || key === '') return
+    const current = this.grants.get(key)
+    if (scope === 'once') {
+      this.grants.set(key, { expiresAt: now + ttlMs, remaining: (current?.remaining ?? 0) + 1 })
+      return
+    }
+    this.grants.set(key, { expiresAt: now + ttlMs, remaining: Infinity })
+  }
+
+  consumeGrant(key) {
+    const grant = this.grants.get(key)
+    if (!grant) return false
+    if (grant.expiresAt <= Date.now()) {
+      this.grants.delete(key)
+      return false
+    }
+    if (Number.isFinite(grant.remaining)) {
+      grant.remaining -= 1
+      if (grant.remaining <= 0) this.grants.delete(key)
+    }
+    return true
+  }
+
+  revokeAll() {
+    this.grants.clear()
+  }
+}
+
+function normalizeConfig(config) {
+  const capabilities = { ...DEFAULT_POLICY.capabilities }
+  for (const [key, value] of Object.entries(config.capabilities ?? {})) {
+    if (CAPABILITIES.includes(key) && ['auto', 'ask', 'deny', 'allow'].includes(value)) capabilities[key] = value
+  }
+  return {
+    allowedRoots: Array.isArray(config.allowedRoots) ? config.allowedRoots.map(String) : [],
+    capabilities,
+    allowedTools: Array.isArray(config.allowedTools) ? config.allowedTools.map(String) : [],
+    approvalTtlMs:
+      Number.isFinite(config.approvalTtlMs) && config.approvalTtlMs > 0
+        ? config.approvalTtlMs
+        : DEFAULT_POLICY.approvalTtlMs,
+  }
+}
+
+function collectPaths(args) {
+  const paths = []
+  for (const key of ['path', 'file_path', 'cwd', 'dir', 'directory']) {
+    if (typeof args?.[key] === 'string' && args[key] !== '') paths.push(args[key])
+  }
+  if (Array.isArray(args?.paths)) {
+    for (const value of args.paths) if (typeof value === 'string' && value !== '') paths.push(value)
+  }
+  return paths
+}