livedesk 0.1.208 → 0.1.210

package/hub/src/agents/agent-audit-store.js

@@ -0,0 +1,93 @@
+import { appendFile, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import crypto from 'node:crypto';
+import os from 'node:os';
+import path from 'node:path';
+
+const MAX_AUDIT_RECORDS = 2000;
+const MAX_AUDIT_FILE_RECORDS = 2250;
+const MAX_AUDIT_FIELD = 4000;
+
+function safeText(value, max = MAX_AUDIT_FIELD) {
+  return String(value ?? '').replace(/[\0\r\n]/g, ' ').trim().slice(0, max);
+}
+
+function redact(value, depth = 0) {
+  if (depth > 4) return '[truncated]';
+  if (Array.isArray(value)) return value.slice(0, 100).map(item => redact(item, depth + 1));
+  if (!value || typeof value !== 'object') return typeof value === 'string' ? safeText(value) : value;
+  return Object.fromEntries(Object.entries(value).slice(0, 100).map(([key, child]) => [
+    key,
+    /content|command|script|token|secret|password|credential|api[-_]?key|authorization/i.test(key) ? '[redacted]' : redact(child, depth + 1)
+  ]));
+}
+
+export function createAgentAuditStore({ dataDir = path.join(os.homedir(), '.livedesk') } = {}) {
+  const filePath = path.join(dataDir, 'agent-audit.jsonl');
+  let records = null;
+  let rewriteNeeded = false;
+  let fileRecordCount = 0;
+  let writeQueue = Promise.resolve();
+
+  async function load() {
+    if (records) return records;
+    try {
+      const allLines = (await readFile(filePath, 'utf8')).split(/\r?\n/).filter(Boolean);
+      fileRecordCount = allLines.length;
+      rewriteNeeded = allLines.length > MAX_AUDIT_FILE_RECORDS;
+      records = allLines.slice(-MAX_AUDIT_RECORDS).map(line => JSON.parse(line)).filter(item => item && typeof item === 'object');
+    } catch {
+      records = [];
+    }
+    return records;
+  }
+
+  function normalize(event = {}) {
+    return {
+      auditId: safeText(event.auditId || crypto.randomUUID(), 100),
+      timestamp: new Date().toISOString(),
+      runId: safeText(event.runId, 100),
+      deviceIds: Array.isArray(event.deviceIds) ? [...new Set(event.deviceIds.map(item => safeText(item, 128)).filter(Boolean))].slice(0, 500) : [],
+      event: safeText(event.event, 100),
+      toolName: safeText(event.toolName, 120),
+      category: safeText(event.category, 80),
+      decision: safeText(event.decision, 40),
+      status: safeText(event.status, 40),
+      permissionMode: safeText(event.permissionMode, 40),
+      policyHash: safeText(event.policyHash, 100),
+      argumentsHash: safeText(event.argumentsHash, 100),
+      details: redact(event.details || {})
+    };
+  }
+
+  return {
+    async record(event) {
+      const record = normalize(event);
+      writeQueue = writeQueue.then(async () => {
+        const current = await load();
+        current.push(record);
+        fileRecordCount += 1;
+        if (current.length > MAX_AUDIT_RECORDS) {
+          current.splice(0, current.length - MAX_AUDIT_RECORDS);
+        }
+        if (fileRecordCount > MAX_AUDIT_FILE_RECORDS) rewriteNeeded = true;
+        await mkdir(path.dirname(filePath), { recursive: true });
+        if (rewriteNeeded) {
+          const tempPath = `${filePath}.${process.pid}.${crypto.randomUUID()}.tmp`;
+          await writeFile(tempPath, `${current.map(item => JSON.stringify(item)).join('\n')}\n`, { encoding: 'utf8', mode: 0o600 });
+          await rename(tempPath, filePath);
+          fileRecordCount = current.length;
+          rewriteNeeded = false;
+        } else {
+          await appendFile(filePath, `${JSON.stringify(record)}\n`, { encoding: 'utf8', mode: 0o600 });
+        }
+      });
+      await writeQueue;
+      return record;
+    },
+    async list({ runId = '', limit = 200 } = {}) {
+      const current = await load();
+      const normalizedLimit = Math.max(1, Math.min(500, Number(limit) || 200));
+      return current.filter(item => !runId || item.runId === String(runId)).slice(-normalizedLimit).reverse();
+    }
+  };
+}

package/hub/src/agents/agent-manager.js

@@ -169,6 +169,7 @@ export function createAgentManager({
       return runtime.start(input);
     },
     getRun(runId) { return runtime?.get(runId) || null; },
-    cancelRun(runId) { return runtime?.cancel(runId) || null; }
+    cancelRun(runId) { return runtime?.cancel(runId) || null; },
+    cancelAllRuns() { return runtime?.cancelAll?.() || 0; }
   };
 }

package/hub/src/agents/agent-permission-store.js

@@ -0,0 +1,78 @@
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { DEFAULT_CUSTOM_AGENT_PERMISSION_CATEGORIES, normalizeAgentPermissionCategories } from './agent-permissions.js';
+
+function safePolicyId(value) {
+  const id = String(value || '').trim().replace(/[^a-zA-Z0-9_.:-]/g, '-').slice(0, 80);
+  return id || 'custom-default';
+}
+
+function publicPolicy(policy) {
+  return {
+    id: policy.id,
+    name: policy.name,
+    categories: { ...policy.categories },
+    createdAt: policy.createdAt,
+    updatedAt: policy.updatedAt
+  };
+}
+
+export function createAgentPermissionStore({ dataDir = path.join(os.homedir(), '.livedesk') } = {}) {
+  const filePath = path.join(dataDir, 'agent-permission-policies.json');
+  let policies;
+
+  async function load() {
+    if (policies) return policies;
+    try {
+      const parsed = JSON.parse(await readFile(filePath, 'utf8'));
+      policies = new Map(Object.entries(parsed && typeof parsed === 'object' ? parsed : {}).map(([id, value]) => [safePolicyId(id), {
+        id: safePolicyId(id),
+        name: String(value?.name || id).slice(0, 120),
+        categories: normalizeAgentPermissionCategories(value?.categories, DEFAULT_CUSTOM_AGENT_PERMISSION_CATEGORIES),
+        createdAt: String(value?.createdAt || new Date().toISOString()),
+        updatedAt: String(value?.updatedAt || new Date().toISOString())
+      }]));
+    } catch {
+      policies = new Map();
+    }
+    if (!policies.has('custom-default')) {
+      const now = new Date().toISOString();
+      policies.set('custom-default', { id: 'custom-default', name: 'Custom default', categories: { ...DEFAULT_CUSTOM_AGENT_PERMISSION_CATEGORIES }, createdAt: now, updatedAt: now });
+    }
+    return policies;
+  }
+
+  async function save() {
+    const current = await load();
+    const value = Object.fromEntries([...current].map(([id, policy]) => [id, policy]));
+    await mkdir(path.dirname(filePath), { recursive: true });
+    const temporaryPath = `${filePath}.${process.pid}.${crypto.randomUUID()}.tmp`;
+    await writeFile(temporaryPath, `${JSON.stringify(value, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+    await rename(temporaryPath, filePath);
+  }
+
+  return {
+    async list() { return [...await load()].map(([, policy]) => publicPolicy(policy)); },
+    async get(id = 'custom-default') {
+      const current = await load();
+      return publicPolicy(current.get(safePolicyId(id)) || current.get('custom-default'));
+    },
+    async upsert({ id = 'custom-default', name = 'Custom default', categories = {} } = {}) {
+      const current = await load();
+      const policyId = safePolicyId(id);
+      const previous = current.get(policyId);
+      const now = new Date().toISOString();
+      current.set(policyId, {
+        id: policyId,
+        name: String(name || policyId).slice(0, 120),
+        categories: normalizeAgentPermissionCategories(categories, previous?.categories || DEFAULT_CUSTOM_AGENT_PERMISSION_CATEGORIES),
+        createdAt: previous?.createdAt || now,
+        updatedAt: now
+      });
+      await save();
+      return publicPolicy(current.get(policyId));
+    }
+  };
+}

package/hub/src/agents/agent-permissions.js

@@ -0,0 +1,200 @@
+import crypto from 'node:crypto';
+import { getAgentToolDefinition } from './agent-tool-registry.js';
+
+export const AGENT_PERMISSION_MODES = Object.freeze(['ask', 'safe-auto', 'full-access', 'custom']);
+export const AGENT_PERMISSION_DECISIONS = Object.freeze(['allow', 'ask', 'deny']);
+export const AGENT_PERMISSION_CATEGORIES = Object.freeze([
+  'read',
+  'processControl',
+  'serviceControl',
+  'applicationControl',
+  'fileRead',
+  'fileWrite',
+  'fileDelete',
+  'shell',
+  'script',
+  'softwareInstall',
+  'network',
+  'systemPower',
+  'systemConfiguration',
+  'userAccount'
+]);
+
+const DEFAULT_CUSTOM_CATEGORIES = Object.freeze({
+  read: 'allow',
+  processControl: 'ask',
+  serviceControl: 'ask',
+  applicationControl: 'ask',
+  fileRead: 'ask',
+  fileWrite: 'ask',
+  fileDelete: 'ask',
+  shell: 'ask',
+  script: 'ask',
+  softwareInstall: 'ask',
+  network: 'ask',
+  systemPower: 'ask',
+  systemConfiguration: 'ask',
+  userAccount: 'deny'
+});
+
+const PRESET_CATEGORIES = Object.freeze({
+  ask: {
+    ...DEFAULT_CUSTOM_CATEGORIES,
+    userAccount: 'ask'
+  },
+  'safe-auto': {
+    read: 'allow',
+    processControl: 'allow',
+    serviceControl: 'allow',
+    applicationControl: 'allow',
+    fileRead: 'allow',
+    fileWrite: 'allow',
+    fileDelete: 'ask',
+    shell: 'ask',
+    script: 'allow',
+    softwareInstall: 'ask',
+    network: 'allow',
+    systemPower: 'ask',
+    systemConfiguration: 'ask',
+    userAccount: 'deny'
+  },
+  'full-access': {
+    read: 'allow',
+    processControl: 'allow',
+    serviceControl: 'allow',
+    applicationControl: 'allow',
+    fileRead: 'allow',
+    fileWrite: 'allow',
+    fileDelete: 'allow',
+    shell: 'allow',
+    script: 'allow',
+    softwareInstall: 'allow',
+    network: 'allow',
+    systemPower: 'allow',
+    systemConfiguration: 'allow',
+    userAccount: 'ask'
+  }
+});
+
+const TOOL_CATEGORY_ALIASES = Object.freeze({
+  'process.list': 'read',
+  'service.status': 'read',
+  'system.health': 'read',
+  'gpu.status': 'read',
+  'disk.status': 'read',
+  'diagnostics.collect': 'read'
+});
+
+function normalizeIds(value) {
+  return [...new Set((Array.isArray(value) ? value : [])
+    .map(item => String(item || '').trim())
+    .filter(Boolean))].sort().slice(0, 500);
+}
+
+function normalizeDecision(value, fallback = 'ask') {
+  return AGENT_PERMISSION_DECISIONS.includes(String(value || '').toLowerCase())
+    ? String(value).toLowerCase()
+    : fallback;
+}
+
+export function normalizeAgentPermissionCategories(value, fallback = DEFAULT_CUSTOM_CATEGORIES) {
+  const source = value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+  return Object.fromEntries(AGENT_PERMISSION_CATEGORIES.map(category => [
+    category,
+    normalizeDecision(source[category], fallback[category] || 'ask')
+  ]));
+}
+
+export function getPresetAgentPermissionCategories(mode, customCategories) {
+  const normalizedMode = AGENT_PERMISSION_MODES.includes(mode) ? mode : 'ask';
+  if (normalizedMode === 'custom') return normalizeAgentPermissionCategories(customCategories);
+  return normalizeAgentPermissionCategories(PRESET_CATEGORIES[normalizedMode] || PRESET_CATEGORIES.ask);
+}
+
+export function createAgentPermissionPolicy({ mode = 'ask', deviceIds = [], customCategories, maxToolCalls, now = new Date() } = {}) {
+  const normalizedMode = AGENT_PERMISSION_MODES.includes(String(mode)) ? String(mode) : 'ask';
+  const categories = getPresetAgentPermissionCategories(normalizedMode, customCategories);
+  const defaultMax = normalizedMode === 'ask' ? 30 : normalizedMode === 'safe-auto' ? 50 : normalizedMode === 'full-access' ? 100 : 50;
+  const requestedMax = Number(maxToolCalls);
+  const boundedMax = Number.isFinite(requestedMax) ? Math.max(1, Math.min(100, Math.floor(requestedMax))) : defaultMax;
+  const createdAt = new Date(now).toISOString();
+  const expiresAt = new Date(new Date(now).getTime() + 60 * 60 * 1000).toISOString();
+  return {
+    policyVersion: 1,
+    mode: normalizedMode,
+    deviceIds: normalizeIds(deviceIds),
+    categories,
+    maxToolCalls: boundedMax,
+    expiresAt,
+    createdAt
+  };
+}
+
+export function hashAgentPermissionPolicy(policy) {
+  const canonical = JSON.stringify({
+    policyVersion: policy?.policyVersion,
+    mode: policy?.mode,
+    deviceIds: normalizeIds(policy?.deviceIds),
+    categories: normalizeAgentPermissionCategories(policy?.categories),
+    allowedAppIds: normalizeIds(policy?.allowedAppIds),
+    allowedServiceNames: normalizeIds(policy?.allowedServiceNames),
+    allowedFileRoots: normalizeIds(policy?.allowedFileRoots),
+    allowedDomains: normalizeIds(policy?.allowedDomains),
+    allowedExecutables: normalizeIds(policy?.allowedExecutables),
+    maxToolCalls: Number(policy?.maxToolCalls) || 0,
+    expiresAt: String(policy?.expiresAt || '')
+  });
+  return crypto.createHash('sha256').update(canonical).digest('hex');
+}
+
+function targetIdsFromArgs(args, fallback = []) {
+  return normalizeIds(args?.deviceIds?.length ? args.deviceIds : fallback);
+}
+
+function isSafeAutoRelativePath(value) {
+  const text = String(value || '').trim();
+  if (!text || text.length > 600 || text.startsWith('/') || /^[A-Za-z]:[\\/]/.test(text) || text.startsWith('\\\\')) return false;
+  const segments = text.replaceAll('\\', '/').split('/').filter(Boolean);
+  return segments.length > 0 && !segments.includes('..');
+}
+
+function safeAutoConstraint(tool, args, mode) {
+  if (mode !== 'safe-auto') return '';
+  if (tool.category === 'fileWrite' && !isSafeAutoRelativePath(args?.path)) {
+    return 'Safe Auto file writes are limited to relative paths inside the LiveDesk files directory.';
+  }
+  if (tool.category === 'script') {
+    const scriptPath = String(args?.path || '').trim().toLowerCase();
+    if (!isSafeAutoRelativePath(scriptPath) || !scriptPath.replaceAll('\\', '/').startsWith('scripts/') || !/\.(ps1|psm1|sh|bash|py|js|mjs|cmd|bat)$/.test(scriptPath)) {
+      return 'Safe Auto scripts must be registered relative script files inside the LiveDesk files directory.';
+    }
+  }
+  return '';
+}
+
+export function evaluateAgentToolPermission({ policy, toolName, arguments: args = {}, deviceIds = [] } = {}) {
+  const tool = getAgentToolDefinition(toolName);
+  if (!tool) return { decision: 'deny', category: 'unknown', risk: 'critical', reason: 'Unknown or unregistered Agent tool.' };
+  const allowed = new Set(normalizeIds(policy?.deviceIds));
+  const requested = targetIdsFromArgs(args, deviceIds);
+  if (requested.some(deviceId => !allowed.has(deviceId))) {
+    return { decision: 'deny', category: tool.category, risk: tool.risk, reason: 'The tool requested a device outside the selected Agent scope.' };
+  }
+  if (policy?.expiresAt && Date.parse(policy.expiresAt) <= Date.now()) {
+    return { decision: 'deny', category: tool.category, risk: 'high', reason: 'The Agent permission policy has expired.' };
+  }
+  const category = TOOL_CATEGORY_ALIASES[tool.name.replace(/^livedesk\./, '')] || tool.category;
+  const constraintError = safeAutoConstraint(tool, args, policy?.mode);
+  if (constraintError) {
+    return { decision: 'deny', category, risk: tool.risk, reason: constraintError };
+  }
+  const decision = normalizeDecision(policy?.categories?.[category], 'deny');
+  return {
+    decision,
+    category,
+    risk: tool.risk,
+    reason: decision === 'allow' ? `Allowed by ${policy?.mode || 'current'} policy.` : decision === 'ask' ? 'This operation requires approval in the current policy.' : 'This operation is denied by the current policy.'
+  };
+}
+
+export const DEFAULT_CUSTOM_AGENT_PERMISSION_CATEGORIES = Object.freeze({ ...DEFAULT_CUSTOM_CATEGORIES });