livedesk 0.1.205 → 0.1.206

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

@@ -0,0 +1,18 @@
+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));
+}

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

@@ -136,7 +136,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,34 @@ 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',
+  'USERPROFILE',
+  'HOME',
+  'APPDATA',
+  'LOCALAPPDATA',
+  '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 +89,91 @@ 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,
+      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 };
+  for (const key of SAFE_ENV_KEYS) {
+    const value = process.env[key];
+    if (value !== undefined && value !== '') env[key] = value;
+  }
+  if (!env.HOME) env.HOME = os.homedir();
+  if (!env.USERPROFILE && process.platform === 'win32') env.USERPROFILE = os.homedir();
+  if (!env.Path && env.PATH) env.Path = env.PATH;
+  if (!env.PATH && env.Path) env.PATH = env.Path;
+  return env;
+}
+
+async function ensureCodexHome(codexHome) {
+  await mkdir(codexHome, { recursive: true, mode: 0o700 });
+  const targetAuthPath = path.join(codexHome, '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.
+  }
+  try {
+    await link(path.join(os.homedir(), '.codex', 'auth.json'), targetAuthPath);
+  } catch {
+    // A fresh installation may not have a CLI auth file yet. Codex will then
+    // report the normal auth-required state through getStatus().
+  }
+}
+
+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,6 +198,24 @@ 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-task-timeout' ? 504 : 409, retryable: code === 'codex-task-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'),
@@ -132,6 +227,28 @@ export function createCodexAgentRuntime({
   let activeCount = 0;
   let codexModulePromise;
   const workspace = path.resolve(dataDir, 'agent-workspace');
+  const codexHome = path.resolve(dataDir, 'codex-home');
+
+  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 => {
@@ -158,7 +275,8 @@ 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'
@@ -176,8 +294,9 @@ export function createCodexAgentRuntime({
     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 });
+    await ensureCodexHome(codexHome);
     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 } } });
+    const codex = new Codex({ env: safeCodexEnv(codexHome), config: baseCodexConfig() });
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), Math.min(30000, settings.codexTaskTimeoutMs));
     try {
@@ -238,19 +357,37 @@ export function createCodexAgentRuntime({
   async function execute(run, input) {
     activeCount += 1;
     let session;
+    let timeoutTimer;
     try {
       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-task-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;
+      if (run.abortController.signal.aborted) {
+        session.cancel();
+        if (run.abortReason === 'timeout') throw codexAbortError('codex-task-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 loadCodex();
-      const codex = new Codex({ config: codexConfig({ mcpServerPath, mcpUrl: session.url, token: session.token, workspace }) });
+      const codex = new Codex({ 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)
@@ -261,6 +398,7 @@ export function createCodexAgentRuntime({
       for await (const event of streamed.events) {
         emit(run, event);
         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 +410,13 @@ 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-task-timeout';
+      } else if (run.abortReason === 'tool-limit') {
+        run.status = 'failed';
+        run.error = 'codex-tool-limit-reached';
+      } else if (isAbortError(error) || run.abortController.signal.aborted) {
         run.status = 'cancelled';
         run.error = 'cancelled-by-user';
       } else {
@@ -286,7 +430,9 @@ 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);
     }
   }
 
@@ -295,6 +441,8 @@ export function createCodexAgentRuntime({
     if (!instruction) throw new AgentProviderError('agent-invalid-instruction', 'Instruction is required.', { status: 400 });
     const settings = await settingsStore.get();
     if (!settings.enabled) throw new AgentProviderError('agent-ai-disabled', 'Agent AI is disabled in Settings.', { status: 409 });
+    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',
@@ -309,10 +457,11 @@ export function createCodexAgentRuntime({
       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: safeAgentDeviceIds(input.deviceIds), resumeThreadId: input.resumeThreadId });
     return publicRun(run);
   }
 
@@ -324,6 +473,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 +482,5 @@ export function createCodexAgentRuntime({
     return publicRun(run);
   }
 
-  return { getStatus, testConnection, start, get, cancel, workspace };
+  return { getStatus, testConnection, start, get, cancel, workspace, codexHome };
 }

package/hub/src/server.js

@@ -16,6 +16,7 @@ import { toFilesystemHttpError } from './filesystem/directory-reader.js';
 import { createAgentManager } from './agents/agent-manager.js';
 import { AgentSettingsStore } from './agents/agent-settings.js';
 import { createCodexAgentRuntime } from './agents/codex-agent-runtime.js';
+import { createAgentDeviceScope, selectAgentDeviceIds } from './agents/agent-device-scope.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const webDistCandidates = [
@@ -210,23 +211,50 @@ const remoteHub = createRemoteHub({
 const agentDataDir = process.env.LIVEDESK_DATA_DIR || undefined;
 const agentMcpSessions = new Map();
 const agentMcpRunBatches = new Map();
+const agentMcpRunCleanupTimers = new Map();
+const AGENT_MCP_RUN_TTL_MS = 60 * 60 * 1000;
+const MAX_AGENT_MCP_RUN_RECORDS = 500;
 
-function connectedAgentDevices(requestedIds = []) {
+function connectedAgentDeviceIds() {
   const devices = remoteHub.listDevices({ includeDataUrl: false });
-  const connected = devices.filter(device => device.connected === true);
-  const requested = [...new Set((Array.isArray(requestedIds) ? requestedIds : [])
-    .map(value => String(value || '').trim())
-    .filter(Boolean))].slice(0, 500);
-  const allowed = new Set(connected.map(device => device.deviceId));
-  return (requested.length > 0 ? requested : [...allowed]).filter(deviceId => allowed.has(deviceId));
+  return devices
+    .filter(device => device.connected === true)
+    .map(device => String(device.deviceId || '').trim())
+    .filter(Boolean)
+    .slice(0, 500);
 }
 
-function createAgentMcpSession({ runId, signal }) {
+function deleteAgentMcpRunBatches(runId) {
+  agentMcpRunBatches.delete(runId);
+  const timer = agentMcpRunCleanupTimers.get(runId);
+  if (timer) clearTimeout(timer);
+  agentMcpRunCleanupTimers.delete(runId);
+}
+
+function pruneAgentMcpRunBatches() {
+  while (agentMcpRunBatches.size >= MAX_AGENT_MCP_RUN_RECORDS) {
+    const oldestRunId = agentMcpRunBatches.keys().next().value;
+    if (!oldestRunId) break;
+    deleteAgentMcpRunBatches(oldestRunId);
+  }
+}
+
+function scheduleAgentMcpRunCleanup(runId) {
+  if (agentMcpRunCleanupTimers.has(runId)) return;
+  const timer = setTimeout(() => deleteAgentMcpRunBatches(runId), AGENT_MCP_RUN_TTL_MS);
+  timer.unref?.();
+  agentMcpRunCleanupTimers.set(runId, timer);
+}
+
+function createAgentMcpSession({ runId, signal, allowedDeviceIds: allowedDeviceIdsInput = [] }) {
   const token = crypto.randomBytes(32).toString('hex');
+  const allowedDeviceIds = createAgentDeviceScope(allowedDeviceIdsInput, connectedAgentDeviceIds());
+  pruneAgentMcpRunBatches();
   const session = {
     token,
     runId: String(runId || ''),
     signal,
+    allowedDeviceIds,
     cancelled: false,
     cancel() {
       if (this.cancelled) return;
@@ -235,7 +263,7 @@ function createAgentMcpSession({ runId, signal }) {
     }
   };
   agentMcpSessions.set(token, session);
-  agentMcpRunBatches.set(session.runId, new Set());
+  if (!agentMcpRunBatches.has(session.runId)) agentMcpRunBatches.set(session.runId, new Set());
   return { token, url: `http://127.0.0.1:${httpPort}`, cancel: () => session.cancel() };
 }
 
@@ -243,6 +271,7 @@ function destroyAgentMcpSession(token) {
   const session = agentMcpSessions.get(token);
   if (session) session.cancel();
   agentMcpSessions.delete(token);
+  if (session) scheduleAgentMcpRunCleanup(session.runId);
 }
 
 function delayAgentMcp(ms) {
@@ -252,9 +281,13 @@ function delayAgentMcp(ms) {
 async function dispatchAgentMcpTool(session, name, args = {}) {
   if (session.cancelled || session.signal?.aborted) return { ok: false, error: 'cancelled-by-user' };
   if (name === 'livedesk.list_devices') {
-    const requested = connectedAgentDevices(args.deviceIds);
+    const requested = selectAgentDeviceIds({
+      allowedDeviceIds: session.allowedDeviceIds,
+      requestedDeviceIds: args.deviceIds,
+      connectedDeviceIds: connectedAgentDeviceIds()
+    });
     const devices = remoteHub.listDevices({ includeDataUrl: false })
-      .filter(device => requested.length === 0 ? device.connected === true : requested.includes(device.deviceId))
+      .filter(device => requested.includes(device.deviceId))
       .slice(0, 500)
       .map(device => ({ deviceId: device.deviceId, deviceName: device.deviceName, hostname: device.hostname, connected: device.connected === true, platform: device.platform, capabilities: device.capabilities }));
     return { ok: true, devices };
@@ -269,7 +302,11 @@ async function dispatchAgentMcpTool(session, name, args = {}) {
   };
   const operation = operationByTool[name];
   if (!operation) return { ok: false, error: 'unsupported-livedesk-tool' };
-  const targetIds = connectedAgentDevices(args.deviceIds);
+  const targetIds = selectAgentDeviceIds({
+    allowedDeviceIds: session.allowedDeviceIds,
+    requestedDeviceIds: args.deviceIds,
+    connectedDeviceIds: connectedAgentDeviceIds()
+  });
   if (targetIds.length === 0) return { ok: false, error: 'no-target-devices' };
   const targetQuery = operation === 'process.list'
     ? String(args.processName || '').replace(/[\0\r\n]/g, ' ').trim().slice(0, 120)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livedesk",
-  "version": "0.1.205",
+  "version": "0.1.206",
   "description": "LiveDesk Hub and client launcher",
   "type": "module",
   "bin": {