livedesk 0.1.205 → 0.1.207

package/hub/src/agents/agent-device-scope.js

@@ -0,0 +1,29 @@
+function normalizeIds(value) {
+  const source = Array.isArray(value) ? value : [];
+  return [...new Set(source.map(item => String(item || '').trim()).filter(Boolean))].slice(0, 500);
+}
+
+export function createAgentDeviceScope(allowedDeviceIds, fallbackDeviceIds = []) {
+  const requested = normalizeIds(allowedDeviceIds);
+  const fallback = normalizeIds(fallbackDeviceIds);
+  return new Set(requested.length > 0 ? requested : fallback);
+}
+
+export function selectAgentDeviceIds({ allowedDeviceIds, requestedDeviceIds, connectedDeviceIds }) {
+  const allowed = allowedDeviceIds instanceof Set ? allowedDeviceIds : new Set(normalizeIds(allowedDeviceIds));
+  const requested = normalizeIds(requestedDeviceIds);
+  const connected = new Set(normalizeIds(connectedDeviceIds));
+  const candidates = requested.length > 0 ? requested : [...allowed];
+  return candidates.filter(deviceId => allowed.has(deviceId) && connected.has(deviceId));
+}
+
+export function resolveAgentTargetIds({ allowedDeviceIds, requestedDeviceIds, connectedDeviceIds }) {
+  const requested = normalizeIds(requestedDeviceIds);
+  const allowed = allowedDeviceIds instanceof Set ? allowedDeviceIds : new Set(normalizeIds(allowedDeviceIds));
+  const deviceIds = selectAgentDeviceIds({ allowedDeviceIds: allowed, requestedDeviceIds: requested, connectedDeviceIds });
+  if (deviceIds.length > 0) return { deviceIds, error: '' };
+  if (requested.length > 0 && requested.every(deviceId => !allowed.has(deviceId))) {
+    return { deviceIds: [], error: 'agent-target-outside-selection' };
+  }
+  return { deviceIds: [], error: 'agent-no-target-devices' };
+}

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

@@ -37,13 +37,19 @@ export function createAgentManager({
   async function getCodexStatus() {
     if (!runtime) return { installed: false, authenticated: 'unknown', status: 'unavailable', codexPath: '' };
     if (statusCache.value && statusCache.expiresAt > Date.now()) return statusCache.value;
-    const value = publicCodexStatus(await runtime.getStatus());
+    let value;
+    try {
+      value = publicCodexStatus(await runtime.getStatus());
+    } catch (error) {
+      value = publicCodexStatus({ installed: true, authenticated: 'unknown', status: error?.code || 'security-unavailable', detail: error?.message || 'Codex security isolation is unavailable.' });
+    }
     statusCache = { value, expiresAt: Date.now() + 10000 };
     return value;
   }
 
   async function publicSettings() {
     const current = await settings.get();
+    const { codexMaxTurns: _codexMaxTurns, ...exposedSettings } = current;
     let hasApiKey = false;
     let apiKeyPreview = '';
     let secretStoreAvailable = true;
@@ -57,8 +63,15 @@ export function createAgentManager({
       }
     }
     const codex = await getCodexStatus();
+    const securityStatus = runtime?.getSecurityStatus?.() || {
+      isolatedCodexHome: false,
+      restrictedEnvironment: false,
+      livedeskMcpOnly: false,
+      selectedDeviceScopeEnforced: false,
+      failClosed: true
+    };
     return {
-      ...current,
+      ...exposedSettings,
       hasApiKey,
       apiKeyPreview,
       secretStoreAvailable,
@@ -66,7 +79,8 @@ export function createAgentManager({
       codexAuth: codex.authenticated,
       codexStatus: codex.status,
       codexPath: codex.codexPath,
-      agentWorkspacePath: current.codexWorkingDirectory
+      agentWorkspacePath: current.codexWorkingDirectory,
+      securityStatus
     };
   }
 
@@ -136,7 +150,9 @@ export function createAgentManager({
       const { current, active } = await currentProvider();
       if (!current.enabled || !current.generateSummary) throw new AgentProviderError('agent-summary-disabled', 'Agent summaries are disabled in Settings.', { status: 409 });
       if (current.provider === AGENT_PROVIDER_CODEX) {
-        return { summary: String(input?.summary?.results?.length ? `${input.summary.completed || 0} completed, ${input.summary.failed || 0} failed.` : 'LiveDesk Agent run completed.').slice(0, 1200), modelId: current.codexModelId || 'Codex default' };
+        const source = input && typeof input === 'object' ? input : {};
+        const results = Array.isArray(source.results) ? source.results : [];
+        return { summary: String(results.length ? `${source.completed || 0} completed, ${source.failed || 0} failed.` : 'LiveDesk Agent run completed.').slice(0, 1200), modelId: current.codexModelId || 'Codex default' };
       }
       const source = input && typeof input === 'object' ? input : {};
       const results = Array.isArray(source.results) ? source.results : [];

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

@@ -98,11 +98,9 @@ function normalizeBaseUrl(value) {
 }
 
 function normalizeWorkingDirectory(value) {
-  const candidate = stringValue(value, DEFAULT_AGENT_WORKSPACE, 500);
-  if (!candidate || candidate.includes('\0')) {
-    throw new AgentSettingsError('agent-invalid-working-directory', 'Codex working directory is invalid.');
-  }
-  return path.resolve(candidate);
+  // The agent runtime owns this directory. Do not allow a browser/API caller
+  // to move Codex into a user project or an arbitrary filesystem root.
+  return DEFAULT_AGENT_WORKSPACE;
 }
 
 export function normalizeAgentSettings(value = {}) {

package/hub/src/agents/codex-agent-runtime.js

@@ -1,5 +1,5 @@
 import crypto from 'node:crypto';
-import { mkdir } from 'node:fs/promises';
+import { access, link, mkdir } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
@@ -9,6 +9,30 @@ import { AGENT_PROVIDER_CODEX } from './agent-settings.js';
 
 const require = createRequire(import.meta.url);
 const MAX_EVENTS = 240;
+const MAX_RUNS = 500;
+const RUN_TTL_MS = 60 * 60 * 1000;
+const SAFE_ENV_KEYS = [
+  'Path',
+  'PATH',
+  'SystemRoot',
+  'SYSTEMROOT',
+  'ComSpec',
+  'TEMP',
+  'TMP',
+  'WINDIR',
+  'LANG',
+  'LC_ALL',
+  'TMPDIR'
+];
+const LIVEDESK_MCP_TOOLS = [
+  'livedesk.list_devices',
+  'livedesk.get_system_health',
+  'livedesk.get_gpu_status',
+  'livedesk.get_disk_status',
+  'livedesk.list_processes',
+  'livedesk.get_service_status',
+  'livedesk.collect_diagnostics'
+];
 
 function safeText(value, max = 2400) {
   return String(value || '').replace(/[\0\r]/g, ' ').trim().slice(0, max);
@@ -61,42 +85,114 @@ function codexThreadOptions(settings, workspace) {
   };
 }
 
-function codexConfig({ mcpServerPath, mcpUrl, token, workspace }) {
+function baseCodexConfig() {
   return {
     approval_policy: 'never',
     sandbox_mode: 'read-only',
     web_search: 'disabled',
     features: {
       shell_tool: false,
-      web_search: false,
+      unified_exec: false,
+      shell_snapshot: false,
       apps: false,
-      multi_agent: false
+      multi_agent: false,
+      web_search: false,
+      skill_mcp_dependency_install: false,
+      memories: false,
+      plugins: false,
+      remote_plugin: false
     },
     tools: {
       web_search: false,
       view_image: false
     },
-    mcp_servers: {
-      livedesk: {
-        command: process.execPath,
-        args: [mcpServerPath],
-        cwd: workspace,
-        env: {
-          LIVEDESK_AGENT_MCP_URL: mcpUrl,
-          LIVEDESK_AGENT_MCP_TOKEN: token
-        },
-        enabled: true,
-        required: true,
-        startup_timeout_sec: 10,
-        tool_timeout_sec: 150
-      }
+    apps: {
+      _default: { enabled: false }
+    },
+    plugins: {},
+    mcp_servers: {}
+  };
+}
+
+function codexConfig({ mcpServerPath, mcpUrl, token, workspace }) {
+  const config = baseCodexConfig();
+  config.mcp_servers = {
+    livedesk: {
+      command: process.execPath,
+      args: [mcpServerPath],
+      cwd: workspace,
+      env: {
+        LIVEDESK_AGENT_MCP_URL: mcpUrl,
+        LIVEDESK_AGENT_MCP_TOKEN: token
+      },
+      enabled: true,
+      required: true,
+      enabled_tools: LIVEDESK_MCP_TOOLS,
+      startup_timeout_sec: 10,
+      tool_timeout_sec: 150
     }
   };
+  return config;
 }
 
-function runCli(cliPath, args, timeoutMs = 5000) {
+function safeCodexEnv(codexHome) {
+  const env = {
+    CODEX_HOME: codexHome,
+    HOME: codexHome,
+    USERPROFILE: codexHome,
+    APPDATA: path.join(codexHome, 'AppData', 'Roaming'),
+    LOCALAPPDATA: path.join(codexHome, 'AppData', 'Local')
+  };
+  for (const key of SAFE_ENV_KEYS) {
+    const value = process.env[key];
+    if (value !== undefined && value !== '') env[key] = value;
+  }
+  if (!env.Path && env.PATH) env.Path = env.PATH;
+  if (!env.PATH && env.Path) env.PATH = env.Path;
+  return env;
+}
+
+async function ensureCodexHome(codexHome) {
+  const resolvedHome = path.resolve(codexHome);
+  const globalHome = path.resolve(os.homedir(), '.codex');
+  if (!resolvedHome || resolvedHome === globalHome) {
+    throw new AgentProviderError('codex-isolation-unavailable', 'Codex requires a dedicated LiveDesk home.', { status: 503 });
+  }
+  try {
+    await mkdir(resolvedHome, { recursive: true, mode: 0o700 });
+    if (await access(path.join(resolvedHome, 'config.toml')).then(() => true, () => false)) {
+      throw new AgentProviderError('codex-environment-isolation-failed', 'The dedicated Codex home contains an unmanaged config.toml.', { status: 503 });
+    }
+  } catch (error) {
+    if (error instanceof AgentProviderError) throw error;
+    const wrapped = new AgentProviderError('codex-environment-isolation-failed', 'The dedicated Codex home could not be prepared.', { status: 503 });
+    wrapped.cause = error;
+    throw wrapped;
+  }
+  const targetAuthPath = path.join(resolvedHome, 'auth.json');
+  try {
+    await access(targetAuthPath);
+    return;
+  } catch {
+    // Keep the SDK isolated from the user's global config while reusing the
+    // CLI-owned auth file when the user is already signed in. The runtime
+    // never reads or copies the credential contents.
+  }
+  const sourceAuthPath = path.join(os.homedir(), '.codex', 'auth.json');
+  if (!(await access(sourceAuthPath).then(() => true, () => false))) return;
+  try {
+    await link(sourceAuthPath, targetAuthPath);
+  } catch (error) {
+    const wrapped = new AgentProviderError('codex-environment-isolation-failed', 'The Codex authentication bridge could not be prepared.', { status: 503 });
+    wrapped.cause = error;
+    throw wrapped;
+  }
+}
+
+function runCli(cliPath, args, timeoutMs = 5000, env = process.env) {
   return new Promise((resolve, reject) => {
     const child = spawn(process.execPath, [cliPath, ...args], {
+      env,
       windowsHide: true,
       stdio: ['ignore', 'pipe', 'pipe']
     });
@@ -121,17 +217,82 @@ function runCli(cliPath, args, timeoutMs = 5000) {
   });
 }
 
+function isTerminalStatus(status) {
+  return ['completed', 'failed', 'cancelled'].includes(status);
+}
+
+function runAgeMs(run) {
+  return Math.max(0, Date.now() - Date.parse(run.updatedAt || run.createdAt || 0));
+}
+
+function codexAbortError(code, message) {
+  return new AgentProviderError(code, message, { status: code === 'codex-run-timeout' ? 504 : 409, retryable: code === 'codex-run-timeout' });
+}
+
+function safeAgentDeviceIds(value) {
+  return [...new Set((Array.isArray(value) ? value : [])
+    .map(item => String(item || '').trim())
+    .filter(Boolean))].slice(0, 500);
+}
+
 export function createCodexAgentRuntime({
   settingsStore,
   dataDir = path.join(os.homedir(), '.livedesk'),
   mcpServerPath,
   createMcpSession,
-  destroyMcpSession
+  destroyMcpSession,
+  createCodexClient: injectedCodexClient,
+  getCodexStatus: injectedCodexStatus
 } = {}) {
   const runs = new Map();
   let activeCount = 0;
   let codexModulePromise;
   const workspace = path.resolve(dataDir, 'agent-workspace');
+  const codexHome = path.resolve(dataDir, 'codex-home');
+
+  function securityStatus() {
+    return {
+      isolatedCodexHome: codexHome !== path.resolve(os.homedir(), '.codex'),
+      restrictedEnvironment: true,
+      livedeskMcpOnly: typeof createMcpSession === 'function' && Boolean(mcpServerPath),
+      selectedDeviceScopeEnforced: typeof createMcpSession === 'function',
+      failClosed: true
+    };
+  }
+
+  function assertSecurityConfiguration() {
+    const status = securityStatus();
+    if (!status.isolatedCodexHome || !status.restrictedEnvironment || !status.livedeskMcpOnly || !status.selectedDeviceScopeEnforced) {
+      throw new AgentProviderError('codex-unsupported-security-config', 'Codex security isolation is not available.', { status: 503 });
+    }
+  }
+
+  async function createCodexClient(options) {
+    if (typeof injectedCodexClient === 'function') return injectedCodexClient(options);
+    const { Codex } = await loadCodex();
+    return new Codex(options);
+  }
+
+  function scheduleRunCleanup(run) {
+    const timer = setTimeout(() => {
+      if (runs.get(run.runId) === run && isTerminalStatus(run.status) && runAgeMs(run) >= RUN_TTL_MS) {
+        runs.delete(run.runId);
+      }
+    }, RUN_TTL_MS + 1000);
+    timer.unref?.();
+  }
+
+  function pruneRuns() {
+    for (const [runId, run] of runs) {
+      if (isTerminalStatus(run.status) && runAgeMs(run) >= RUN_TTL_MS) runs.delete(runId);
+    }
+    if (runs.size < MAX_RUNS) return;
+    for (const [runId, run] of runs) {
+      if (!isTerminalStatus(run.status)) continue;
+      runs.delete(runId);
+      if (runs.size < MAX_RUNS) break;
+    }
+  }
 
   async function loadCodex() {
     if (!codexModulePromise) codexModulePromise = import('@openai/codex-sdk').catch(error => {
@@ -151,6 +312,7 @@ export function createCodexAgentRuntime({
   }
 
   async function getStatus() {
+    if (typeof injectedCodexStatus === 'function') return injectedCodexStatus();
     const pathToCli = cliPath();
     if (!pathToCli) {
       return { installed: false, authenticated: 'unknown', status: 'not-installed', codexPath: '' };
@@ -158,26 +320,29 @@ export function createCodexAgentRuntime({
     let authenticated = 'unknown';
     let detail = '';
     try {
-      const result = await runCli(pathToCli, ['login', 'status']);
+      await ensureCodexHome(codexHome);
+      const result = await runCli(pathToCli, ['login', 'status'], 5000, safeCodexEnv(codexHome));
       detail = safeText(result.stdout || result.stderr, 300);
       authenticated = /logged in|authenticated|chatgpt/i.test(`${result.stdout}\n${result.stderr}`)
         ? 'signed-in'
         : 'not-signed-in';
     } catch (error) {
+      if (error instanceof AgentProviderError) throw error;
       detail = safeText(error?.message, 300);
     }
     return { installed: true, authenticated, status: authenticated === 'signed-in' ? 'ready' : 'auth-required', codexPath: pathToCli, detail };
   }
 
   async function testConnection() {
+    assertSecurityConfiguration();
     const startedAt = Date.now();
     const status = await getStatus();
     if (!status.installed) throw new AgentProviderError('codex-sdk-not-installed', 'Codex SDK is not installed.', { status: 503 });
     if (status.authenticated !== 'signed-in') throw new AgentProviderError('codex-auth-required', 'Sign in with the Codex CLI first.', { status: 401 });
     const settings = await settingsStore.get();
     await mkdir(workspace, { recursive: true });
-    const { Codex } = await loadCodex();
-    const codex = new Codex({ config: { approval_policy: 'never', sandbox_mode: 'read-only', web_search: 'disabled', features: { shell_tool: false, web_search: false, apps: false, multi_agent: false }, tools: { web_search: false, view_image: false } } });
+    await ensureCodexHome(codexHome);
+    const codex = await createCodexClient({ env: safeCodexEnv(codexHome), config: baseCodexConfig() });
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), Math.min(30000, settings.codexTaskTimeoutMs));
     try {
@@ -238,19 +403,37 @@ export function createCodexAgentRuntime({
   async function execute(run, input) {
     activeCount += 1;
     let session;
+    let timeoutTimer;
     try {
+      assertSecurityConfiguration();
       const settings = await settingsStore.get();
+      const timeoutMs = Math.max(1000, Number(settings.codexTaskTimeoutMs) || 600000);
+      timeoutTimer = setTimeout(() => {
+        run.abortReason = 'timeout';
+        run.abortController.abort();
+        try { session?.cancel(); } catch { /* best effort */ }
+      }, timeoutMs);
+      timeoutTimer.unref?.();
       await mkdir(workspace, { recursive: true });
       if (activeCount > settings.maxConcurrentRequests) {
         throw new AgentProviderError('agent-concurrency-limit', 'The LiveDesk Agent concurrency limit is reached.', { status: 429, retryable: true });
       }
+      if (run.abortController.signal.aborted) {
+        if (run.abortReason === 'timeout') throw codexAbortError('codex-run-timeout', 'The Codex task exceeded its timeout.');
+        throw Object.assign(new Error('The Codex task was cancelled.'), { name: 'AbortError' });
+      }
       const status = await getStatus();
       if (!status.installed) throw new AgentProviderError('codex-sdk-not-installed', 'Codex SDK is not installed.', { status: 503 });
       if (status.authenticated !== 'signed-in') throw new AgentProviderError('codex-auth-required', 'Sign in with the Codex CLI first.', { status: 401 });
-      session = createMcpSession({ runId: run.runId, signal: run.abortController.signal });
+      session = createMcpSession({ runId: run.runId, signal: run.abortController.signal, allowedDeviceIds: input.deviceIds });
       run.mcpToken = session.token;
-      const { Codex } = await loadCodex();
-      const codex = new Codex({ config: codexConfig({ mcpServerPath, mcpUrl: session.url, token: session.token, workspace }) });
+      if (run.abortController.signal.aborted) {
+        session.cancel();
+        if (run.abortReason === 'timeout') throw codexAbortError('codex-run-timeout', 'The Codex task exceeded its timeout.');
+        throw Object.assign(new Error('The Codex task was cancelled.'), { name: 'AbortError' });
+      }
+      await ensureCodexHome(codexHome);
+      const codex = await createCodexClient({ env: safeCodexEnv(codexHome), config: codexConfig({ mcpServerPath, mcpUrl: session.url, token: session.token, workspace }) });
       const threadOptions = codexThreadOptions(settings, workspace);
       const thread = input.resumeThreadId && settings.codexResumeSessions
         ? codex.resumeThread(String(input.resumeThreadId), threadOptions)
@@ -260,7 +443,17 @@ export function createCodexAgentRuntime({
       const streamed = await thread.runStreamed(promptFor({ instruction: run.instruction, deviceIds: input.deviceIds }), { signal: run.abortController.signal });
       for await (const event of streamed.events) {
         emit(run, event);
+        if (event.type === 'turn.started') {
+          run.turnCount += 1;
+          if (run.turnCount > settings.codexMaxTurns) {
+            run.abortReason = 'turn-limit';
+            run.abortController.abort();
+            session.cancel();
+            throw new AgentProviderError('codex-turn-limit-reached', 'Codex exceeded the LiveDesk turn limit.', { status: 409 });
+          }
+        }
         if (run.toolCallCount > settings.codexMaxToolCalls) {
+          run.abortReason = 'tool-limit';
           run.abortController.abort();
           session.cancel();
           throw new AgentProviderError('codex-tool-limit-reached', 'Codex exceeded the LiveDesk tool-call limit.', { status: 409 });
@@ -272,7 +465,16 @@ export function createCodexAgentRuntime({
       }
       if (run.status === 'running') run.status = 'completed';
     } catch (error) {
-      if (isAbortError(error) || run.abortController.signal.aborted) {
+      if (run.abortReason === 'timeout') {
+        run.status = 'failed';
+        run.error = 'codex-run-timeout';
+      } else if (run.abortReason === 'tool-limit') {
+        run.status = 'failed';
+        run.error = 'codex-tool-limit-reached';
+      } else if (run.abortReason === 'turn-limit') {
+        run.status = 'failed';
+        run.error = 'codex-turn-limit-reached';
+      } else if (isAbortError(error) || run.abortController.signal.aborted) {
         run.status = 'cancelled';
         run.error = 'cancelled-by-user';
       } else {
@@ -286,15 +488,22 @@ export function createCodexAgentRuntime({
         try { session.cancel(); } catch { /* best effort */ }
         destroyMcpSession(session.token);
       }
+      clearTimeout(timeoutTimer);
       run.updatedAt = new Date().toISOString();
+      if (isTerminalStatus(run.status)) scheduleRunCleanup(run);
     }
   }
 
   async function start(input = {}) {
     const instruction = safeText(input.instruction, 4000);
     if (!instruction) throw new AgentProviderError('agent-invalid-instruction', 'Instruction is required.', { status: 400 });
+    const deviceIds = safeAgentDeviceIds(input.deviceIds);
+    if (deviceIds.length === 0) throw new AgentProviderError('agent-no-target-devices', 'Select at least one connected device.', { status: 400 });
     const settings = await settingsStore.get();
     if (!settings.enabled) throw new AgentProviderError('agent-ai-disabled', 'Agent AI is disabled in Settings.', { status: 409 });
+    assertSecurityConfiguration();
+    pruneRuns();
+    if (runs.size >= MAX_RUNS) throw new AgentProviderError('agent-run-limit', 'The LiveDesk Agent run history is full.', { status: 429, retryable: true });
     const run = {
       runId: crypto.randomUUID(),
       status: 'queued',
@@ -306,13 +515,15 @@ export function createCodexAgentRuntime({
       createdAt: new Date().toISOString(),
       updatedAt: new Date().toISOString(),
       toolCallCount: 0,
+      turnCount: 0,
       batchIds: new Set(),
       events: [],
       abortController: new AbortController(),
+      abortReason: '',
       mcpToken: ''
     };
     runs.set(run.runId, run);
-    void execute(run, { deviceIds: Array.isArray(input.deviceIds) ? input.deviceIds.slice(0, 500) : [], resumeThreadId: input.resumeThreadId });
+    void execute(run, { deviceIds, resumeThreadId: input.resumeThreadId });
     return publicRun(run);
   }
 
@@ -324,6 +535,8 @@ export function createCodexAgentRuntime({
   function cancel(runId) {
     const run = runs.get(String(runId || ''));
     if (!run) return null;
+    if (isTerminalStatus(run.status)) return publicRun(run);
+    run.abortReason = 'user';
     run.abortController.abort();
     run.status = 'cancelled';
     run.error = 'cancelled-by-user';
@@ -331,5 +544,5 @@ export function createCodexAgentRuntime({
     return publicRun(run);
   }
 
-  return { getStatus, testConnection, start, get, cancel, workspace };
+  return { getStatus, testConnection, start, get, cancel, workspace, codexHome, getSecurityStatus: securityStatus };
 }

package/hub/src/remote-hub.js

@@ -1832,6 +1832,11 @@ export function createRemoteHub(options = {}) {
         if (!batch) {
             return { ok: false, error: 'task-not-found' };
         }
+        if (!['running', 'queued'].includes(batch.status)) {
+            return { ok: true, ...serializeTaskBatch(batch) };
+        }
+
+        batch.cancelRequested = true;
 
         for (const item of batch.results) {
             if (!['targeted', 'queued', 'running'].includes(item.status)) {
@@ -2821,6 +2826,7 @@ export function createRemoteHub(options = {}) {
             completed: 0,
             failed: targets.length > 0 ? 0 : 1,
             timedOut: 0,
+            cancelRequested: false,
             results: targets.map(deviceId => ({
                 deviceId,
                 deviceName: safeString(devices.get(deviceId)?.deviceName || devices.get(deviceId)?.hostname || deviceId, 160),
@@ -2890,7 +2896,9 @@ export function createRemoteHub(options = {}) {
         batch.pending = results.filter(item => ['targeted', 'queued', 'running'].includes(item.status)).length;
         batch.updatedAt = new Date().toISOString();
 
-        if (batch.total === 0) {
+        if (batch.cancelRequested && batch.pending === 0) {
+            batch.status = 'cancelled';
+        } else if (batch.total === 0) {
             batch.status = 'failed';
         } else if (batch.completed + batch.failed + batch.cancelled >= batch.total) {
             batch.status = batch.failed > 0 ? 'completed-with-failures' : 'completed';
@@ -2919,6 +2927,10 @@ export function createRemoteHub(options = {}) {
             return null;
         }
 
+        if (batch.cancelRequested && item.status === 'cancelled') {
+            return batch;
+        }
+
         item.ok = true;
         item.status = safeString(task.status, 40) || 'queued';
         item.stage = safeString(task.stage, 160) || (item.status === 'running' ? 'Working' : '');