@livedesk/hub 0.1.30 → 0.1.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livedesk/hub",
-  "version": "0.1.30",
+  "version": "0.1.31",
   "description": "LiveDesk local Hub API and browser frame bridge",
   "type": "module",
   "main": "src/server.js",
@@ -16,7 +16,7 @@
   },
   "dependencies": {
     "@ffmpeg-installer/ffmpeg": "^1.1.0",
-    "@livedesk/runtime-core": "0.1.2",
+    "@livedesk/runtime-core": "0.1.3",
     "@openai/codex-sdk": "0.145.0",
     "cors": "^2.8.5",
     "express": "^4.21.2",

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

@@ -1,4 +1,4 @@
-import { appendFile, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { appendFile, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import crypto from 'node:crypto';
 import os from 'node:os';
 import path from 'node:path';
@@ -84,10 +84,20 @@ export function createAgentAuditStore({ dataDir = path.join(os.homedir(), '.live
       await writeQueue;
       return record;
     },
-    async list({ runId = '', limit = 200 } = {}) {
+    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();
-    }
-  };
-}
+      return current.filter(item => !runId || item.runId === String(runId)).slice(-normalizedLimit).reverse();
+    },
+    async clear() {
+      writeQueue = writeQueue.then(async () => {
+        await rm(filePath, { force: true });
+        records = [];
+        fileRecordCount = 0;
+        rewriteNeeded = false;
+      });
+      await writeQueue;
+      return { ok: true };
+    }
+  };
+}

package/src/agents/agent-permissions.js

@@ -181,9 +181,15 @@ function safeAutoConstraint(tool, args, mode) {
   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.' };
+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.' };
+  // This is deliberately redundant with the filtered MCP registry. A future
+  // registry edit must not make an AI mutation executable merely by exposing
+  // a definition again.
+  if (tool.mutating === true || tool.readOnly !== true) {
+    return { decision: 'deny', category: tool.category, risk: 'critical', reason: 'AI mutating tools are disabled in the first public product.' };
+  }
   const allowed = new Set(normalizeIds(policy?.deviceIds));
   const requested = targetIdsFromArgs(args, deviceIds);
   if (requested.some(deviceId => !allowed.has(deviceId))) {

package/src/agents/agent-tool-registry.js

@@ -24,7 +24,7 @@ function withRequiredInput(properties, required = []) {
 const taskPermission = { ask: 'ask', safeAuto: 'ask', fullAccess: 'allow' };
 const readTaskPermission = { ask: 'allow', safeAuto: 'allow', fullAccess: 'allow' };
 
-export const AGENT_TOOL_DEFINITIONS = Object.freeze([
+const ALL_AGENT_TOOL_DEFINITIONS = Object.freeze([
   {
     name: 'livedesk.list_devices',
     description: 'List connected LiveDesk Clients. This is read-only.',
@@ -313,6 +313,20 @@ export const AGENT_TOOL_DEFINITIONS = Object.freeze([
   }
 ]);
 
+// LD-SEC-AI-001: the first public product exposes read-only AI tools only.
+// Keep the retired names explicit so every boundary can fail closed for an old
+// model, stale MCP schema, or rolling-update Client without advertising the
+// capability or relying on a permission preset.
+export const RETIRED_AGENT_MUTATING_TOOL_NAMES = Object.freeze(
+  ALL_AGENT_TOOL_DEFINITIONS.filter(tool => tool.mutating === true).map(tool => tool.name)
+);
+
+const retiredMutatingToolNames = new Set(RETIRED_AGENT_MUTATING_TOOL_NAMES);
+
+export const AGENT_TOOL_DEFINITIONS = Object.freeze(
+  ALL_AGENT_TOOL_DEFINITIONS.filter(tool => tool.readOnly === true && tool.mutating !== true)
+);
+
 export const AGENT_TOOL_NAMES = Object.freeze(AGENT_TOOL_DEFINITIONS.map(tool => tool.name));
 
 const toolByName = new Map(AGENT_TOOL_DEFINITIONS.map(tool => [tool.name, tool]));
@@ -320,3 +334,7 @@ const toolByName = new Map(AGENT_TOOL_DEFINITIONS.map(tool => [tool.name, tool])
 export function getAgentToolDefinition(name) {
   return toolByName.get(String(name || '').trim()) || null;
 }
+
+export function isRetiredAgentMutatingToolName(name) {
+  return retiredMutatingToolNames.has(String(name || '').trim());
+}

package/src/captures/capture-store.js

@@ -53,11 +53,13 @@ async function atomicJson(filePath, value) {
 }
 
 export class CaptureStore {
-  constructor({ dataDir } = {}) {
+  constructor({ dataDir, getRetentionPolicy = () => 'never', onRetentionDelete = () => {} } = {}) {
     this.root = captureRoot(dataDir);
     this.indexPath = path.join(this.root, 'index.json');
     this.sessions = new Map();
     this.index = null;
+    this.getRetentionPolicy = typeof getRetentionPolicy === 'function' ? getRetentionPolicy : () => 'never';
+    this.onRetentionDelete = typeof onRetentionDelete === 'function' ? onRetentionDelete : () => {};
   }
 
   async initialize() {
@@ -199,6 +201,7 @@ export class CaptureStore {
 
   async list() {
     await this.ready();
+    await this.enforceRetention();
     return this.index.captures.map(publicRecord);
   }
 
@@ -218,10 +221,54 @@ export class CaptureStore {
   }
 
   resolveFilePath(record) {
-    if (record?.filePath) return record.filePath;
     const folder = record?.kind === 'screenshot' ? 'images' : record?.kind === 'timelapse' ? 'timelapses' : 'recordings';
     const extension = record?.mimeType === 'image/png' ? '.png' : '.webm';
-    return path.join(this.root, folder, `${safeName(record?.id, 'missing')}${extension}`);
+    const fallback = path.join(this.root, folder, `${safeName(record?.id, 'missing')}${extension}`);
+    const candidate = path.resolve(record?.filePath || fallback);
+    const relative = path.relative(path.resolve(this.root), candidate);
+    return !relative || (!relative.startsWith('..') && !path.isAbsolute(relative)) ? candidate : fallback;
+  }
+
+  async enforceRetention({ now = Date.now() } = {}) {
+    await this.ready();
+    const policy = String(this.getRetentionPolicy() || 'never').trim();
+    const retentionDays = policy === '7-days' ? 7 : policy === '30-days' ? 30 : 0;
+    if (!retentionDays) return { policy: 'never', removed: 0, removedBytes: 0 };
+    const cutoff = Number(now) - retentionDays * 24 * 60 * 60_000;
+    const expired = this.index.captures.filter(record => {
+      const createdAt = Date.parse(record?.createdAt || '');
+      return Number.isFinite(createdAt) && createdAt < cutoff;
+    });
+    if (expired.length === 0) return { policy, removed: 0, removedBytes: 0 };
+    const expiredIds = new Set(expired.map(record => record.id));
+    this.index.captures = this.index.captures.filter(record => !expiredIds.has(record.id));
+    await Promise.all(expired.map(record => rm(this.resolveFilePath(record), { force: true })));
+    await atomicJson(this.indexPath, { captures: this.index.captures });
+    const result = {
+      policy,
+      removed: expired.length,
+      removedBytes: expired.reduce((sum, record) => sum + Math.max(0, Number(record.sizeBytes) || 0), 0)
+    };
+    await this.onRetentionDelete(result);
+    return result;
+  }
+
+  async removeAll() {
+    await this.ready();
+    const records = [...this.index.captures];
+    const sessions = [...this.sessions.values()];
+    this.sessions.clear();
+    await Promise.all([
+      ...records.map(record => rm(this.resolveFilePath(record), { force: true })),
+      ...sessions.map(session => rm(session.tempPath, { force: true }))
+    ]);
+    this.index.captures = [];
+    await atomicJson(this.indexPath, { captures: [] });
+    return {
+      removed: records.length,
+      removedBytes: records.reduce((sum, record) => sum + Math.max(0, Number(record.sizeBytes) || 0), 0),
+      cancelledSessions: sessions.length
+    };
   }
 
   async _record(record) {

package/src/filesystem/shared-folders.js

@@ -104,6 +104,14 @@ export class HubSharedFolders {
     return { ok: removed };
   }
 
+  async clear() {
+    await this.ensureLoaded();
+    const removed = this.folders.size;
+    this.folders.clear();
+    await this.persist();
+    return { ok: true, removed };
+  }
+
   async sync(id, deviceIds, remoteDirectory) {
     await this.ensureLoaded();
     const folder = this.folders.get(String(id || ''));

package/src/filesystem/transfer-jobs.js

@@ -29,11 +29,14 @@ function markUpdated(job) {
 }
 
 export class HubTransferJobs {
-  constructor({ filesystem, remoteHub, maxConcurrent = 2, commandResultTimeoutMs = COMMAND_RESULT_TIMEOUT_MS } = {}) {
+  constructor({ filesystem, remoteHub, maxConcurrent = 2, commandResultTimeoutMs = COMMAND_RESULT_TIMEOUT_MS, getMaxFileSizeBytes = () => Number.MAX_SAFE_INTEGER } = {}) {
     this.filesystem = filesystem;
     this.remoteHub = remoteHub;
     this.maxConcurrent = Math.max(1, Number(maxConcurrent) || 2);
     this.commandResultTimeoutMs = Math.max(1_000, Number(commandResultTimeoutMs) || COMMAND_RESULT_TIMEOUT_MS);
+    this.getMaxFileSizeBytes = typeof getMaxFileSizeBytes === 'function'
+      ? getMaxFileSizeBytes
+      : () => Number.MAX_SAFE_INTEGER;
     this.jobs = new Map();
     this.queue = [];
     this.running = 0;
@@ -98,6 +101,21 @@ export class HubTransferJobs {
     return snapshot(job);
   }
 
+  clear() {
+    let cancelled = 0;
+    for (const job of this.jobs.values()) {
+      if (!['completed', 'partially-failed', 'failed', 'cancelled'].includes(job.state)) {
+        this.cancel(job.jobId);
+        cancelled += 1;
+      }
+    }
+    const removed = this.jobs.size;
+    this.jobs.clear();
+    this.queue = [];
+    this.pendingCommands.clear();
+    return { cancelled, removed };
+  }
+
   pump() {
     while (this.running < this.maxConcurrent && this.queue.length > 0) {
       const job = this.queue.shift();
@@ -118,6 +136,10 @@ export class HubTransferJobs {
         ? { files: job.files, totalBytes: job.files.reduce((sum, file) => sum + Number(file.size || 0), 0) }
         : await this.filesystem.scan(job.itemIds);
       if (job.cancelled) return;
+      const maxFileSizeBytes = Math.max(1, Number(this.getMaxFileSizeBytes()) || 1);
+      if (scan.files.some(file => Number(file.size || 0) > maxFileSizeBytes)) {
+        throw new Error('file-transfer-file-too-large');
+      }
       job.totalFiles = scan.files.length;
       job.totalBytes = scan.totalBytes;
       job.state = 'sending';
@@ -160,10 +182,12 @@ export class HubTransferJobs {
   async sendFile(job, file) {
     const activeTargets = () => job.deviceIds.filter(deviceId => !job.failedTargets.has(deviceId));
     if (Number(file.size || 0) === 0) {
-      await this.sendChunk(job, file, 0, Buffer.alloc(0), true, activeTargets());
+      const sha256 = crypto.createHash('sha256').update(Buffer.alloc(0)).digest('hex');
+      await this.sendChunk(job, file, 0, Buffer.alloc(0), true, activeTargets(), sha256);
       return;
     }
     const stream = fs.createReadStream(file.absolutePath, { highWaterMark: CHUNK_BYTES });
+    const hasher = crypto.createHash('sha256');
     job.currentStream = stream;
     let offset = 0;
     try {
@@ -171,9 +195,11 @@ export class HubTransferJobs {
         if (job.cancelled) return;
         const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
         const final = offset + buffer.length >= Number(file.size || 0);
+        hasher.update(buffer);
+        const sha256 = final ? hasher.digest('hex') : '';
         const targets = activeTargets();
         if (targets.length === 0) throw new Error('all-targets-failed');
-        await this.sendChunk(job, file, offset, buffer, final, targets);
+        await this.sendChunk(job, file, offset, buffer, final, targets, sha256);
         offset += buffer.length;
         job.sentBytes += buffer.length;
         markUpdated(job);
@@ -184,7 +210,7 @@ export class HubTransferJobs {
     }
   }
 
-  async sendChunk(job, file, offset, buffer, final, targets) {
+  async sendChunk(job, file, offset, buffer, final, targets, sha256 = '') {
     const outcomes = await Promise.all(targets.map(async deviceId => {
       if (job.cancelled) return { deviceId, ok: false, error: 'transfer-cancelled' };
       const commandId = crypto.randomUUID();
@@ -200,6 +226,7 @@ export class HubTransferJobs {
           offset,
           totalBytes: Number(file.size || 0),
           final,
+          sha256,
           dataBase64: buffer.toString('base64'),
           lastModified: Number(file.modifiedMs || 0) || 0,
           requestedAt: new Date().toISOString()

package/src/live-desk-update.js

@@ -1,4 +1,5 @@
 import { randomUUID } from 'node:crypto';
+import { fetchSignedUpdateManifest } from '@livedesk/runtime-core/signed-update-manifest';
 
 export const LIVE_DESK_UPDATE_COMMAND = 'livedesk.client-update';
 // 0.1.172 delegates to the exact-version, identity-preserving package
@@ -138,27 +139,27 @@ function buildLegacyUpdateCommand(
   return buildLegacyPlatformCommand(device.platform, payload);
 }
 
-async function fetchLatestPackage(packageName, fetchImpl) {
-  const encodedName = packageName.startsWith('@') ? packageName.replace('/', '%2F') : packageName;
-  const response = await fetchImpl(`https://registry.npmjs.org/${encodedName}/latest`, {
+async function fetchPackageMetadata(packageName, version, fetchImpl) {
+  const encodedName = packageName.startsWith('@') ? packageName.replace('/', '%2F') : packageName;
+  const encodedVersion = encodeURIComponent(String(version || 'latest'));
+  const response = await fetchImpl(`https://registry.npmjs.org/${encodedName}/${encodedVersion}`, {
     headers: { Accept: 'application/json' },
     signal: AbortSignal.timeout(12_000)
   });
   if (!response.ok) {
-    throw new Error(`npm registry returned HTTP ${response.status} for ${packageName}.`);
+    throw new Error(`npm registry returned HTTP ${response.status} for ${packageName}@${version}.`);
   }
   const payload = await response.json();
-  const version = cleanVersion(payload?.version);
-  if (!version) throw new Error(`npm registry returned no version for ${packageName}.`);
-  return { version, package: payload };
-}
-
-export async function fetchLatestLiveDeskRelease(fetchImpl = globalThis.fetch) {
-  if (typeof fetchImpl !== 'function') throw new Error('fetch is unavailable for LiveDesk update checks.');
-  const [manager, client] = await Promise.all([
-    fetchLatestPackage('livedesk', fetchImpl),
-    fetchLatestPackage('@livedesk/client', fetchImpl)
-  ]);
+  const resolvedVersion = cleanVersion(payload?.version);
+  if (!resolvedVersion) throw new Error(`npm registry returned no version for ${packageName}@${version}.`);
+  return { version: resolvedVersion, package: payload };
+}
+
+async function fetchUnsignedRegistryReleaseForTests(fetchImpl) {
+  const [manager, client] = await Promise.all([
+    fetchPackageMetadata('livedesk', 'latest', fetchImpl),
+    fetchPackageMetadata('@livedesk/client', 'latest', fetchImpl)
+  ]);
   const bundledClientVersion = cleanVersion(manager.package?.livedeskClientVersion);
   if (!bundledClientVersion) {
     throw new Error(`livedesk@${manager.version} is missing required livedeskClientVersion release metadata.`);
@@ -172,7 +173,47 @@ export async function fetchLatestLiveDeskRelease(fetchImpl = globalThis.fetch) {
       : `livedesk@${manager.version} bundles Client ${bundledClientVersion}, while @livedesk/client latest is ${client.version}.`,
     managerPackage: manager.package,
     clientPackage: client.package,
-    checkedAt: new Date().toISOString()
+    checkedAt: new Date().toISOString(),
+    manifestVerified: false,
+    blockedVersions: { manager: [], client: [], desktop: [] }
+  };
+}
+
+export async function fetchLatestLiveDeskRelease(fetchImpl = globalThis.fetch, {
+  manifestUrl = '',
+  publicKey = '',
+  now = () => Date.now(),
+  allowUnsignedRegistryForTests = false
+} = {}) {
+  if (typeof fetchImpl !== 'function') throw new Error('fetch is unavailable for LiveDesk update checks.');
+  if (allowUnsignedRegistryForTests === true) return fetchUnsignedRegistryReleaseForTests(fetchImpl);
+  const manifest = await fetchSignedUpdateManifest({ fetchImpl, url: manifestUrl, publicKey, now });
+  const managerRelease = manifest.release.manager;
+  const clientRelease = manifest.release.client;
+  const [manager, client] = await Promise.all([
+    fetchPackageMetadata('livedesk', managerRelease.version, fetchImpl),
+    fetchPackageMetadata('@livedesk/client', clientRelease.version, fetchImpl)
+  ]);
+  const bundledClientVersion = cleanVersion(manager.package?.livedeskClientVersion);
+  if (manager.version !== managerRelease.version
+    || client.version !== clientRelease.version
+    || manager.package?.dist?.integrity !== managerRelease.integrity
+    || client.package?.dist?.integrity !== clientRelease.integrity
+    || bundledClientVersion !== clientRelease.version) {
+    throw new Error('signed-update-registry-binding-invalid');
+  }
+  return {
+    latestManagerVersion: managerRelease.version,
+    latestClientVersion: clientRelease.version,
+    registryClientVersion: client.version,
+    releaseSkew: '',
+    managerPackage: manager.package,
+    clientPackage: client.package,
+    checkedAt: new Date(now()).toISOString(),
+    manifestVerified: true,
+    manifestGeneratedAt: manifest.generatedAt,
+    manifestExpiresAt: manifest.expiresAt,
+    blockedVersions: manifest.blockedVersions
   };
 }
 
@@ -239,6 +280,9 @@ export function createLiveDeskUpdateManager({
   requestHubRestart,
   fetchImpl = globalThis.fetch,
   now = () => Date.now(),
+  updateManifestUrl = '',
+  updatePublicKey = '',
+  allowUnsignedRegistryForTests = false,
   clientBatchSize = LIVE_DESK_UPDATE_CLIENT_BATCH_SIZE,
   targetTimeoutMs = LIVE_DESK_UPDATE_TARGET_TIMEOUT_MS,
   operationTimeoutMs = LIVE_DESK_UPDATE_TIMEOUT_MS,
@@ -275,9 +319,30 @@ export function createLiveDeskUpdateManager({
 
   const checkLatest = async () => {
     if (checkPromise) return checkPromise;
-    checkPromise = fetchLatestLiveDeskRelease(fetchImpl)
-      .then(release => {
-        latestRelease = release;
+    checkPromise = fetchLatestLiveDeskRelease(fetchImpl, {
+      manifestUrl: updateManifestUrl,
+      publicKey: updatePublicKey,
+      now,
+      allowUnsignedRegistryForTests
+    })
+      .then(release => {
+        if (cleanVersion(currentManagerVersion)
+          && compareVersions(release.latestManagerVersion, currentManagerVersion) < 0) {
+          throw new Error('signed-update-manager-downgrade-rejected');
+        }
+        if (cleanVersion(currentClientVersion)
+          && compareVersions(release.latestClientVersion, currentClientVersion) < 0) {
+          throw new Error('signed-update-client-downgrade-rejected');
+        }
+        if (release.blockedVersions?.manager?.includes(cleanVersion(currentManagerVersion))
+          && compareVersions(release.latestManagerVersion, currentManagerVersion) <= 0) {
+          throw new Error('signed-update-blocked-manager-without-safe-upgrade');
+        }
+        if (release.blockedVersions?.client?.includes(cleanVersion(currentClientVersion))
+          && compareVersions(release.latestClientVersion, currentClientVersion) <= 0) {
+          throw new Error('signed-update-blocked-client-without-safe-upgrade');
+        }
+        latestRelease = release;
         checkError = '';
         return release;
       })
@@ -321,6 +386,9 @@ export function createLiveDeskUpdateManager({
       latestClientVersion: latestRelease?.latestClientVersion || '',
       registryClientVersion: latestRelease?.registryClientVersion || '',
       releaseSkew: latestRelease?.releaseSkew || '',
+      manifestVerified: latestRelease?.manifestVerified === true,
+      manifestGeneratedAt: latestRelease?.manifestGeneratedAt || '',
+      manifestExpiresAt: latestRelease?.manifestExpiresAt || '',
       updateAvailable,
       managerUpdateAvailable,
       clientUpdateAvailable,