livedesk 0.1.204 → 0.1.206

package/hub/package.json

@@ -15,6 +15,7 @@
   },
   "dependencies": {
     "@ffmpeg-installer/ffmpeg": "^1.1.0",
+    "@openai/codex-sdk": "0.144.5",
     "cors": "^2.8.5",
     "express": "^4.21.2",
     "ffmpeg-static": "^5.3.0",

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

@@ -1,44 +1,84 @@
 import os from 'node:os';
 import path from 'node:path';
-import { AgentSettingsStore } from './agent-settings.js';
+import { AgentSettingsStore, AGENT_PROVIDER_CODEX, AGENT_PROVIDER_OPENCODE_GO } from './agent-settings.js';
 import { createOsSecretStore } from './secret-store.js';
 import { createOpenCodeGoProvider } from './opencode-go-provider.js';
+import { AgentProviderError } from './provider-errors.js';
+import { createCodexAgentRuntime } from './codex-agent-runtime.js';
 
 function maskApiKey(value) {
   const key = String(value || '');
   return key.length >= 4 ? `••••${key.slice(-4)}` : '';
 }
 
-export function createAgentManager({ dataDir = path.join(os.homedir(), '.livedesk'), settingsStore, secretStore, provider } = {}) {
+function publicCodexStatus(status = {}) {
+  return {
+    installed: status.installed === true,
+    authenticated: ['signed-in', 'not-signed-in'].includes(status.authenticated) ? status.authenticated : 'unknown',
+    status: String(status.status || 'unknown').slice(0, 40),
+    codexPath: String(status.codexPath || '').slice(0, 500),
+    detail: String(status.detail || '').slice(0, 300)
+  };
+}
+
+export function createAgentManager({
+  dataDir = path.join(os.homedir(), '.livedesk'),
+  settingsStore,
+  secretStore,
+  provider,
+  codexRuntime
+} = {}) {
   const settings = settingsStore || new AgentSettingsStore({ dataDir });
   const secrets = secretStore || createOsSecretStore({ dataDir });
-  const agentProvider = provider || createOpenCodeGoProvider();
+  const legacyProvider = provider || createOpenCodeGoProvider();
+  const runtime = codexRuntime;
+  let statusCache = { expiresAt: 0, value: null };
+
+  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());
+    statusCache = { value, expiresAt: Date.now() + 10000 };
+    return value;
+  }
 
   async function publicSettings() {
     const current = await settings.get();
     let hasApiKey = false;
     let apiKeyPreview = '';
     let secretStoreAvailable = true;
-    try {
-      const key = await secrets.getApiKey(current.provider);
-      hasApiKey = Boolean(key);
-      apiKeyPreview = maskApiKey(key);
-    } catch (error) {
-      secretStoreAvailable = false;
+    if (current.provider === AGENT_PROVIDER_OPENCODE_GO) {
+      try {
+        const key = await secrets.getApiKey(AGENT_PROVIDER_OPENCODE_GO);
+        hasApiKey = Boolean(key);
+        apiKeyPreview = maskApiKey(key);
+      } catch {
+        secretStoreAvailable = false;
+      }
     }
-    return { ...current, hasApiKey, apiKeyPreview, secretStoreAvailable };
+    const codex = await getCodexStatus();
+    return {
+      ...current,
+      hasApiKey,
+      apiKeyPreview,
+      secretStoreAvailable,
+      codexInstallation: codex.installed ? 'installed' : 'not-installed',
+      codexAuth: codex.authenticated,
+      codexStatus: codex.status,
+      codexPath: codex.codexPath,
+      agentWorkspacePath: current.codexWorkingDirectory
+    };
+  }
+
+  async function legacyApiKey() {
+    const key = await secrets.getApiKey(AGENT_PROVIDER_OPENCODE_GO);
+    if (!key) throw new AgentProviderError('agent-api-key-missing', 'OpenCode Go API key is not configured.', { status: 401 });
+    return key;
   }
 
-  async function apiKeyForCurrentSettings() {
+  async function currentProvider() {
     const current = await settings.get();
-    const apiKey = await secrets.getApiKey(current.provider);
-    if (!apiKey) {
-      const error = new Error('OpenCode Go API key is not configured.');
-      error.code = 'agent-api-key-missing';
-      error.status = 401;
-      throw error;
-    }
-    return { current, apiKey };
+    return { current, active: current.provider === AGENT_PROVIDER_CODEX ? runtime : legacyProvider };
   }
 
   return {
@@ -48,84 +88,71 @@ export function createAgentManager({ dataDir = path.join(os.homedir(), '.livedes
       const apiKey = typeof nextPatch.apiKey === 'string' ? nextPatch.apiKey.trim() : '';
       delete nextPatch.apiKey;
       const current = await settings.get();
-      if (apiKey) await secrets.setApiKey(current.provider, apiKey);
+      const requestedProvider = String(nextPatch.provider || current.provider);
+      if (apiKey) {
+        if (requestedProvider !== AGENT_PROVIDER_OPENCODE_GO) {
+          throw new AgentProviderError('agent-codex-does-not-use-api-key', 'Codex authentication is owned by the installed Codex CLI.', { status: 400 });
+        }
+        await secrets.setApiKey(AGENT_PROVIDER_OPENCODE_GO, apiKey);
+      }
       await settings.update(nextPatch);
+      statusCache = { expiresAt: 0, value: null };
       return publicSettings();
     },
     async resetSettings() {
       await settings.reset();
+      statusCache = { expiresAt: 0, value: null };
       return publicSettings();
     },
     async deleteApiKey() {
-      const current = await settings.get();
-      await secrets.deleteApiKey(current.provider);
+      await secrets.deleteApiKey(AGENT_PROVIDER_OPENCODE_GO);
       return publicSettings();
     },
     async getModels() {
-      const { current, apiKey } = await apiKeyForCurrentSettings();
-      return agentProvider.getModels(current, apiKey);
+      const { current, active } = await currentProvider();
+      if (current.provider === AGENT_PROVIDER_CODEX) {
+        return [{ id: '', name: 'Codex default', protocol: 'codex-sdk', available: true, capabilities: { supportsReasoningLevel: true, supportsStreaming: true, supportsTools: true } }];
+      }
+      return active.getModels(current, await legacyApiKey());
     },
     async testConnection() {
-      const { current, apiKey } = await apiKeyForCurrentSettings();
-      return agentProvider.testConnection(current, apiKey);
+      const { current, active } = await currentProvider();
+      if (current.provider === AGENT_PROVIDER_CODEX) {
+        if (!active) throw new AgentProviderError('codex-sdk-not-installed', 'Codex SDK is not installed.', { status: 503 });
+        statusCache = { expiresAt: 0, value: null };
+        return active.testConnection();
+      }
+      return active.testConnection(current, await legacyApiKey());
     },
     async createPlan(input) {
-      const current = await settings.get();
-      if (!current.enabled) {
-        const error = new Error('Agent AI is disabled in Settings.');
-        error.code = 'agent-ai-disabled';
-        error.status = 409;
-        throw error;
-      }
-      const apiKey = await secrets.getApiKey(current.provider);
-      if (!apiKey) {
-        const error = new Error('OpenCode Go API key is not configured.');
-        error.code = 'agent-api-key-missing';
-        error.status = 401;
-        throw error;
+      const { current, active } = await currentProvider();
+      if (!current.enabled) throw new AgentProviderError('agent-ai-disabled', 'Agent AI is disabled in Settings.', { status: 409 });
+      if (current.provider === AGENT_PROVIDER_CODEX) {
+        throw new AgentProviderError('agent-codex-run-required', 'Codex runs use the LiveDesk tool loop.', { status: 409 });
       }
-      return agentProvider.createPlan(input, current, apiKey);
+      return active.createPlan(input, current, await legacyApiKey());
     },
     async createSummary(input) {
-      const current = await settings.get();
-      if (!current.enabled || !current.generateSummary) {
-        const error = new Error('Agent summaries are disabled in Settings.');
-        error.code = 'agent-summary-disabled';
-        error.status = 409;
-        throw error;
-      }
-      const apiKey = await secrets.getApiKey(current.provider);
-      if (!apiKey) {
-        const error = new Error('OpenCode Go API key is not configured.');
-        error.code = 'agent-api-key-missing';
-        error.status = 401;
-        throw error;
+      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) {
+        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 : [];
       const safeResults = current.includeRawDeviceDetails
-        ? results.map(result => ({
-          deviceName: String(result?.deviceName || '').slice(0, 120),
-          status: String(result?.status || '').slice(0, 40),
-          result: String(result?.result || '').slice(0, 1200),
-          error: String(result?.error || '').slice(0, 500)
-        }))
-        : results.map(result => ({
-          deviceName: String(result?.deviceName || '').slice(0, 120),
-          status: String(result?.status || '').slice(0, 40),
-          hasResult: Boolean(result?.result),
-          hasError: Boolean(result?.error)
-        }));
-      return agentProvider.createSummary({
-        instruction: String(source.instruction || '').slice(0, 500),
-        operation: String(source.operation || '').slice(0, 80),
-        summary: {
-          total: Number(source.total || results.length),
-          completed: Number(source.completed || 0),
-          failed: Number(source.failed || 0),
-          results: safeResults
-        }
-      }, current, apiKey);
-    }
+        ? results.map(result => ({ deviceName: String(result?.deviceName || '').slice(0, 120), status: String(result?.status || '').slice(0, 40), result: String(result?.result || '').slice(0, 1200), error: String(result?.error || '').slice(0, 500) }))
+        : results.map(result => ({ deviceName: String(result?.deviceName || '').slice(0, 120), status: String(result?.status || '').slice(0, 40), hasResult: Boolean(result?.result), hasError: Boolean(result?.error) }));
+      return active.createSummary({ instruction: String(source.instruction || '').slice(0, 500), operation: String(source.operation || '').slice(0, 80), summary: { total: Number(source.total || results.length), completed: Number(source.completed || 0), failed: Number(source.failed || 0), results: safeResults } }, current, await legacyApiKey());
+    },
+    async startRun(input) {
+      const current = await settings.get();
+      if (current.provider !== AGENT_PROVIDER_CODEX || !runtime) throw new AgentProviderError('agent-codex-not-active', 'Codex SDK is not the active Agent provider.', { status: 409 });
+      return runtime.start(input);
+    },
+    getRun(runId) { return runtime?.get(runId) || null; },
+    cancelRun(runId) { return runtime?.cancel(runId) || null; }
   };
 }

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

@@ -2,12 +2,33 @@ import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 
-export const AGENT_PROVIDER = 'opencode-go';
+export const AGENT_PROVIDER_CODEX = 'codex';
+export const AGENT_PROVIDER_OPENCODE_GO = 'opencode-go';
+export const DEFAULT_AGENT_PROVIDER = AGENT_PROVIDER_CODEX;
 export const DEFAULT_AGENT_BASE_URL = 'https://opencode.ai/zen/go/v1';
-
+export const DEFAULT_CODEX_MODEL_ID = '';
+export const DEFAULT_AGENT_WORKSPACE = path.join(os.homedir(), '.livedesk', 'agent-workspace');
 export const DEFAULT_AGENT_SETTINGS = Object.freeze({
-  enabled: false,
-  provider: AGENT_PROVIDER,
+  settingsVersion: 2,
+  enabled: true,
+  provider: DEFAULT_AGENT_PROVIDER,
+  codexModelId: DEFAULT_CODEX_MODEL_ID,
+  codexReasoningEffort: 'medium',
+  codexSandboxMode: 'read-only',
+  codexApprovalPolicy: 'never',
+  codexWorkingDirectory: DEFAULT_AGENT_WORKSPACE,
+  codexTaskTimeoutMs: 600000,
+  codexMaxTurns: 12,
+  codexMaxToolCalls: 20,
+  codexResumeSessions: true,
+  codexShowDetailedEvents: true,
+  codexNetworkAccessEnabled: false,
+  codexWebSearchMode: 'disabled',
+  deterministicParserFirst: true,
+  generateSummary: true,
+  fallbackSummary: true,
+  includeRawDeviceDetails: false,
+  maxConcurrentRequests: 2,
   baseUrl: DEFAULT_AGENT_BASE_URL,
   defaultModelId: 'deepseek-v4-flash',
   planModelId: '',
@@ -22,15 +43,15 @@ export const DEFAULT_AGENT_SETTINGS = Object.freeze({
   summaryTimeoutMs: 60000,
   retryCount: 1,
   retryDelayMs: 1000,
-  maxConcurrentRequests: 2,
-  streamSummary: false,
-  deterministicParserFirst: true,
-  generateSummary: true,
-  fallbackSummary: true,
-  includeRawDeviceDetails: false
+  streamSummary: false
 });
 
-const REASONING_LEVELS = new Set(['auto', 'low', 'medium', 'high']);
+const PROVIDERS = new Set([AGENT_PROVIDER_CODEX, AGENT_PROVIDER_OPENCODE_GO]);
+const REASONING_EFFORTS = new Set(['minimal', 'low', 'medium', 'high', 'xhigh']);
+const SANDBOX_MODES = new Set(['read-only', 'workspace-write', 'danger-full-access']);
+const APPROVAL_POLICIES = new Set(['never', 'on-request', 'on-failure', 'untrusted']);
+const WEB_SEARCH_MODES = new Set(['disabled', 'cached', 'live']);
+const LEGACY_REASONING_LEVELS = new Set(['auto', 'low', 'medium', 'high']);
 
 export class AgentSettingsError extends Error {
   constructor(code, message) {
@@ -57,13 +78,17 @@ function stringValue(value, fallback, maxLength = 240) {
   return value.trim().slice(0, maxLength);
 }
 
+function enumValue(value, allowed, fallback, code) {
+  const normalized = stringValue(value, fallback, 80).toLowerCase();
+  if (!allowed.has(normalized)) throw new AgentSettingsError(code, `Invalid agent setting: ${normalized}.`);
+  return normalized;
+}
+
 function normalizeBaseUrl(value) {
-  const candidate = stringValue(value, DEFAULT_AGENT_BASE_URL, 500).replace(/\/+$/, '');
+  const candidate = stringValue(value, DEFAULT_AGENT_SETTINGS.baseUrl, 500).replace(/\/+$/, '');
   try {
     const parsed = new URL(candidate);
-    if (!['http:', 'https:'].includes(parsed.protocol) || !parsed.hostname) {
-      throw new Error('invalid protocol');
-    }
+    if (!['http:', 'https:'].includes(parsed.protocol) || !parsed.hostname) throw new Error('invalid protocol');
     parsed.hash = '';
     parsed.search = '';
     return parsed.toString().replace(/\/+$/, '');
@@ -72,19 +97,45 @@ function normalizeBaseUrl(value) {
   }
 }
 
+function normalizeWorkingDirectory(value) {
+  // 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 = {}) {
   const source = value && typeof value === 'object' && !Array.isArray(value) ? value : {};
-  const provider = stringValue(source.provider, DEFAULT_AGENT_SETTINGS.provider, 40);
-  if (provider !== AGENT_PROVIDER) {
-    throw new AgentSettingsError('agent-unsupported-provider', 'Only OpenCode Go is supported by this LiveDesk build.');
-  }
-  const reasoningLevel = stringValue(source.reasoningLevel, DEFAULT_AGENT_SETTINGS.reasoningLevel, 20).toLowerCase();
-  if (!REASONING_LEVELS.has(reasoningLevel)) {
-    throw new AgentSettingsError('agent-invalid-reasoning-level', 'Reasoning level is invalid.');
-  }
+  // The pre-Codex settings file was written by LiveDesk itself and had no
+  // migration marker. Keep the legacy values but move that first-run config
+  // to the new Codex default.
+  const migratingLegacy = Number(source.settingsVersion || 0) < 2 && source.provider === AGENT_PROVIDER_OPENCODE_GO;
+  const provider = migratingLegacy
+    ? DEFAULT_AGENT_PROVIDER
+    : enumValue(source.provider, PROVIDERS, DEFAULT_AGENT_PROVIDER, 'agent-unsupported-provider');
+  const reasoningLevel = enumValue(source.reasoningLevel, LEGACY_REASONING_LEVELS, DEFAULT_AGENT_SETTINGS.reasoningLevel, 'agent-invalid-reasoning-level');
   return {
+    settingsVersion: 2,
     enabled: booleanValue(source.enabled, DEFAULT_AGENT_SETTINGS.enabled),
-    provider: AGENT_PROVIDER,
+    provider,
+    codexModelId: stringValue(source.codexModelId, DEFAULT_AGENT_SETTINGS.codexModelId, 160),
+    codexReasoningEffort: enumValue(source.codexReasoningEffort, REASONING_EFFORTS, DEFAULT_AGENT_SETTINGS.codexReasoningEffort, 'agent-invalid-reasoning-effort'),
+    // These are safety settings, not user-controlled execution toggles. They
+    // are accepted for compatibility but always normalized to the safe floor.
+    codexSandboxMode: 'read-only',
+    codexApprovalPolicy: 'never',
+    codexWorkingDirectory: normalizeWorkingDirectory(source.codexWorkingDirectory),
+    codexTaskTimeoutMs: numberValue(source.codexTaskTimeoutMs, 30000, 1800000, DEFAULT_AGENT_SETTINGS.codexTaskTimeoutMs, true),
+    codexMaxTurns: numberValue(source.codexMaxTurns, 1, 40, DEFAULT_AGENT_SETTINGS.codexMaxTurns, true),
+    codexMaxToolCalls: numberValue(source.codexMaxToolCalls, 1, 100, DEFAULT_AGENT_SETTINGS.codexMaxToolCalls, true),
+    codexResumeSessions: booleanValue(source.codexResumeSessions, DEFAULT_AGENT_SETTINGS.codexResumeSessions),
+    codexShowDetailedEvents: booleanValue(source.codexShowDetailedEvents, DEFAULT_AGENT_SETTINGS.codexShowDetailedEvents),
+    codexNetworkAccessEnabled: false,
+    codexWebSearchMode: 'disabled',
+    deterministicParserFirst: booleanValue(source.deterministicParserFirst, DEFAULT_AGENT_SETTINGS.deterministicParserFirst),
+    generateSummary: booleanValue(source.generateSummary, DEFAULT_AGENT_SETTINGS.generateSummary),
+    fallbackSummary: booleanValue(source.fallbackSummary, DEFAULT_AGENT_SETTINGS.fallbackSummary),
+    includeRawDeviceDetails: booleanValue(source.includeRawDeviceDetails, DEFAULT_AGENT_SETTINGS.includeRawDeviceDetails),
+    maxConcurrentRequests: numberValue(source.maxConcurrentRequests, 1, 8, DEFAULT_AGENT_SETTINGS.maxConcurrentRequests, true),
     baseUrl: normalizeBaseUrl(source.baseUrl ?? DEFAULT_AGENT_SETTINGS.baseUrl),
     defaultModelId: stringValue(source.defaultModelId, DEFAULT_AGENT_SETTINGS.defaultModelId, 160),
     planModelId: stringValue(source.planModelId, DEFAULT_AGENT_SETTINGS.planModelId, 160),
@@ -99,12 +150,7 @@ export function normalizeAgentSettings(value = {}) {
     summaryTimeoutMs: numberValue(source.summaryTimeoutMs, 5000, 180000, DEFAULT_AGENT_SETTINGS.summaryTimeoutMs, true),
     retryCount: numberValue(source.retryCount, 0, 4, DEFAULT_AGENT_SETTINGS.retryCount, true),
     retryDelayMs: numberValue(source.retryDelayMs, 100, 10000, DEFAULT_AGENT_SETTINGS.retryDelayMs, true),
-    maxConcurrentRequests: numberValue(source.maxConcurrentRequests, 1, 8, DEFAULT_AGENT_SETTINGS.maxConcurrentRequests, true),
-    streamSummary: booleanValue(source.streamSummary, DEFAULT_AGENT_SETTINGS.streamSummary),
-    deterministicParserFirst: booleanValue(source.deterministicParserFirst, DEFAULT_AGENT_SETTINGS.deterministicParserFirst),
-    generateSummary: booleanValue(source.generateSummary, DEFAULT_AGENT_SETTINGS.generateSummary),
-    fallbackSummary: booleanValue(source.fallbackSummary, DEFAULT_AGENT_SETTINGS.fallbackSummary),
-    includeRawDeviceDetails: booleanValue(source.includeRawDeviceDetails, DEFAULT_AGENT_SETTINGS.includeRawDeviceDetails)
+    streamSummary: booleanValue(source.streamSummary, DEFAULT_AGENT_SETTINGS.streamSummary)
   };
 }
 
@@ -126,12 +172,8 @@ export class AgentSettingsStore {
     try {
       const raw = await readFile(this.filePath, 'utf8');
       this.settings = normalizeAgentSettings(JSON.parse(raw));
-    } catch (error) {
-      if (error?.code !== 'ENOENT') {
-        this.settings = normalizeAgentSettings(DEFAULT_AGENT_SETTINGS);
-      } else {
-        this.settings = normalizeAgentSettings(DEFAULT_AGENT_SETTINGS);
-      }
+    } catch {
+      this.settings = normalizeAgentSettings(DEFAULT_AGENT_SETTINGS);
     }
     return { ...this.settings };
   }
@@ -151,4 +193,3 @@ export class AgentSettingsStore {
     return { ...next };
   }
 }
-