@livedesk/hub 0.1.27 → 0.1.28

package/package.json

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

package/src/agents/agent-manager.js

@@ -30,23 +30,37 @@ export function createAgentManager({
   const settings = settingsStore || new AgentSettingsStore({ dataDir });
   const runtime = codexRuntime;
   let statusCache = { expiresAt: 0, value: null };
+  let statusRefreshPromise = null;
+  let statusRefreshGeneration = 0;
 
   async function getCodexStatus() {
     if (!runtime) return { installed: false, authenticated: 'unknown', status: 'unavailable', codexPath: '' };
     if (statusCache.value && statusCache.expiresAt > Date.now()) return statusCache.value;
-    let value;
+    if (statusRefreshPromise) return statusRefreshPromise;
+    const generation = statusRefreshGeneration;
+    const refresh = (async () => {
+      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.'
+        });
+      }
+      if (generation === statusRefreshGeneration) {
+        statusCache = { value, expiresAt: Date.now() + 10000 };
+      }
+      return value;
+    })();
+    statusRefreshPromise = refresh;
     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.'
-      });
+      return await refresh;
+    } finally {
+      if (statusRefreshPromise === refresh) statusRefreshPromise = null;
     }
-    statusCache = { value, expiresAt: Date.now() + 10000 };
-    return value;
   }
 
   async function publicSettings() {
@@ -65,6 +79,8 @@ export function createAgentManager({
     async testConnection() {
       if (!runtime) throw new AgentRuntimeError('codex-sdk-not-installed', 'Codex SDK is not installed.', { status: 503 });
       statusCache = { expiresAt: 0, value: null };
+      statusRefreshGeneration += 1;
+      statusRefreshPromise = null;
       return publicCodexConnection(await runtime.testConnection());
     },
     async createSummary(input) {

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

@@ -1,4 +1,5 @@
-import crypto from 'node:crypto';
+import crypto from 'node:crypto';
+import { existsSync } from 'node:fs';
 import { access, link, mkdir, stat, unlink } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
@@ -9,10 +10,25 @@ import { AGENT_TOOL_NAMES } from './agent-tool-registry.js';
 import { createAgentPermissionPolicy, hashAgentPermissionPolicy } from './agent-permissions.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 = [
+const MAX_EVENTS = 240;
+const MAX_RUNS = 500;
+const RUN_TTL_MS = 60 * 60 * 1000;
+const MAX_CODEX_CLI_OUTPUT_BYTES = 64 * 1024;
+const MAX_CODEX_CLI_OUTPUT_CHUNKS = 256;
+const CODEX_CLI_TERMINATE_GRACE_MS = 200;
+const CODEX_CLI_FORCE_CLOSE_MS = 1000;
+const activeCliProcessOwners = new Map();
+let nextCliProcessOwnerId = 0;
+let bundledCodexCliPathCache;
+const CODEX_NATIVE_TARGETS = Object.freeze({
+  'linux:x64': ['@openai/codex-linux-x64', 'x86_64-unknown-linux-musl', 'codex'],
+  'linux:arm64': ['@openai/codex-linux-arm64', 'aarch64-unknown-linux-musl', 'codex'],
+  'darwin:x64': ['@openai/codex-darwin-x64', 'x86_64-apple-darwin', 'codex'],
+  'darwin:arm64': ['@openai/codex-darwin-arm64', 'aarch64-apple-darwin', 'codex'],
+  'win32:x64': ['@openai/codex-win32-x64', 'x86_64-pc-windows-msvc', 'codex.exe'],
+  'win32:arm64': ['@openai/codex-win32-arm64', 'aarch64-pc-windows-msvc', 'codex.exe']
+});
+const SAFE_ENV_KEYS = [
   'Path',
   'PATH',
   'SystemRoot',
@@ -206,33 +222,281 @@ async function ensureCodexHome(codexHome, globalCodexHome, { preferGlobalAuth =
   }
 }
 
-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']
-    });
-    let stdout = '';
-    let stderr = '';
-    const timer = setTimeout(() => {
-      child.kill();
-      reject(Object.assign(new Error('Codex CLI status check timed out.'), { code: 'codex-status-timeout' }));
-    }, timeoutMs);
-    child.stdout.setEncoding('utf8');
-    child.stderr.setEncoding('utf8');
-    child.stdout.on('data', chunk => { stdout += chunk; });
-    child.stderr.on('data', chunk => { stderr += chunk; });
-    child.once('error', error => {
-      clearTimeout(timer);
-      reject(error);
-    });
-    child.once('close', code => {
-      clearTimeout(timer);
-      resolve({ code, stdout: stdout.trim(), stderr: stderr.trim() });
-    });
-  });
-}
+function boundedCliOption(value, fallback, minimum = 1) {
+  const number = Number(value);
+  if (!Number.isFinite(number)) return fallback;
+  return Math.min(fallback, Math.max(minimum, Math.floor(number)));
+}
+
+export function resolveBundledCodexCliPath() {
+  if (bundledCodexCliPathCache !== undefined) return bundledCodexCliPathCache;
+  const target = CODEX_NATIVE_TARGETS[`${process.platform}:${process.arch}`];
+  if (!target) {
+    bundledCodexCliPathCache = '';
+    return bundledCodexCliPathCache;
+  }
+  const [platformPackage, targetTriple, executableName] = target;
+  try {
+    const packageJsonPath = require.resolve(`${platformPackage}/package.json`);
+    const executablePath = path.join(
+      path.dirname(packageJsonPath),
+      'vendor',
+      targetTriple,
+      'bin',
+      executableName
+    );
+    if (existsSync(executablePath)) {
+      bundledCodexCliPathCache = executablePath;
+      return bundledCodexCliPathCache;
+    }
+  } catch {
+    // Older Codex packages may keep the platform payload under the portable
+    // package. That fallback remains a native executable, never the JS wrapper.
+  }
+  try {
+    const portableCliPath = require.resolve('@openai/codex/bin/codex.js');
+    const executablePath = path.join(
+      path.dirname(portableCliPath),
+      '..',
+      'vendor',
+      targetTriple,
+      'bin',
+      executableName
+    );
+    bundledCodexCliPathCache = existsSync(executablePath) ? executablePath : '';
+    return bundledCodexCliPathCache;
+  } catch {
+    bundledCodexCliPathCache = '';
+    return bundledCodexCliPathCache;
+  }
+}
+
+export function getCodexCliProcessOwnerSnapshot() {
+  const owners = [...activeCliProcessOwners.values()];
+  return {
+    activeOwners: owners.length,
+    activeProcesses: owners.filter(owner => owner.child !== null).length,
+    activeStdoutStreams: owners.filter(owner => owner.stdoutStream !== null).length,
+    activeStderrStreams: owners.filter(owner => owner.stderrStream !== null).length,
+    activeListeners: owners.reduce((total, owner) => total + owner.listenerCount, 0),
+    activeTimers: owners.reduce((total, owner) => total
+      + Number(owner.timeoutTimer !== null)
+      + Number(owner.forceKillTimer !== null)
+      + Number(owner.forceCloseTimer !== null), 0),
+    retainedOutputBytes: owners.reduce((total, owner) => total + owner.retainedOutputBytes, 0)
+  };
+}
+
+export function runCli(
+  cliPath,
+  args,
+  timeoutMs = 5000,
+  env = process.env,
+  lifecycleOptions = {}
+) {
+  const maxOutputBytes = boundedCliOption(
+    lifecycleOptions.maxOutputBytes,
+    MAX_CODEX_CLI_OUTPUT_BYTES
+  );
+  const terminateGraceMs = boundedCliOption(
+    lifecycleOptions.terminateGraceMs,
+    CODEX_CLI_TERMINATE_GRACE_MS
+  );
+  const forceCloseMs = boundedCliOption(
+    lifecycleOptions.forceCloseMs,
+    CODEX_CLI_FORCE_CLOSE_MS
+  );
+  const boundedTimeoutMs = Math.max(1, Math.floor(Number(timeoutMs) || 5000));
+  return new Promise((resolve, reject) => {
+    let child;
+    try {
+      const usesNodeLauncher = /\.(?:c|m)?js$/i.test(cliPath);
+      child = spawn(usesNodeLauncher ? process.execPath : cliPath, [
+        ...(usesNodeLauncher ? [cliPath] : []),
+        ...args
+      ], {
+        env,
+        windowsHide: true,
+        stdio: ['ignore', 'pipe', 'pipe']
+      });
+    } catch (error) {
+      reject(error);
+      return;
+    }
+
+    const owner = {
+      id: ++nextCliProcessOwnerId,
+      child,
+      stdoutStream: child.stdout,
+      stderrStream: child.stderr,
+      stdoutChunks: [],
+      stderrChunks: [],
+      stdoutBytes: 0,
+      stderrBytes: 0,
+      retainedOutputBytes: 0,
+      listenerCount: 6,
+      acceptingOutput: true,
+      failure: null,
+      settled: false,
+      timeoutTimer: null,
+      forceKillTimer: null,
+      forceCloseTimer: null
+    };
+    activeCliProcessOwners.set(owner.id, owner);
+
+    const clearOwnerTimer = key => {
+      if (owner[key] === null) return;
+      clearTimeout(owner[key]);
+      owner[key] = null;
+    };
+
+    const removeOutputDataListeners = () => {
+      if (!owner.acceptingOutput) return;
+      owner.acceptingOutput = false;
+      owner.stdoutStream?.removeListener('data', onStdoutData);
+      owner.stderrStream?.removeListener('data', onStderrData);
+      owner.listenerCount = Math.max(0, owner.listenerCount - 2);
+      owner.stdoutStream?.resume();
+      owner.stderrStream?.resume();
+    };
+
+    const cleanupOwner = () => {
+      clearOwnerTimer('timeoutTimer');
+      clearOwnerTimer('forceKillTimer');
+      clearOwnerTimer('forceCloseTimer');
+      owner.child?.removeListener('error', onChildError);
+      owner.child?.removeListener('close', onChildClose);
+      owner.stdoutStream?.removeListener('data', onStdoutData);
+      owner.stdoutStream?.removeListener('error', onStdoutError);
+      owner.stderrStream?.removeListener('data', onStderrData);
+      owner.stderrStream?.removeListener('error', onStderrError);
+      owner.stdoutStream?.destroy();
+      owner.stderrStream?.destroy();
+      owner.child?.unref?.();
+      owner.child = null;
+      owner.stdoutStream = null;
+      owner.stderrStream = null;
+      owner.stdoutChunks.length = 0;
+      owner.stderrChunks.length = 0;
+      owner.stdoutBytes = 0;
+      owner.stderrBytes = 0;
+      owner.retainedOutputBytes = 0;
+      owner.listenerCount = 0;
+      activeCliProcessOwners.delete(owner.id);
+    };
+
+    const finish = code => {
+      if (owner.settled) return;
+      owner.settled = true;
+      const failure = owner.failure;
+      const result = failure ? null : {
+        code,
+        stdout: Buffer.concat(owner.stdoutChunks, owner.stdoutBytes).toString('utf8').trim(),
+        stderr: Buffer.concat(owner.stderrChunks, owner.stderrBytes).toString('utf8').trim()
+      };
+      cleanupOwner();
+      if (failure) reject(failure);
+      else resolve(result);
+    };
+
+    const killExactChild = signal => {
+      if (owner.child === null || owner.child.exitCode !== null || owner.child.signalCode !== null) return;
+      try {
+        owner.child.kill(signal);
+      } catch {
+        // The bounded forced-close owner below still releases every local
+        // handle if the OS reports that this exact child already disappeared.
+      }
+    };
+
+    const failAfterExactChildStops = error => {
+      if (owner.failure || owner.settled) return;
+      owner.failure = error;
+      clearOwnerTimer('timeoutTimer');
+      removeOutputDataListeners();
+      killExactChild('SIGTERM');
+      owner.forceKillTimer = setTimeout(() => {
+        owner.forceKillTimer = null;
+        killExactChild('SIGKILL');
+        owner.forceCloseTimer = setTimeout(() => {
+          owner.forceCloseTimer = null;
+          error.cleanupTimedOut = true;
+          killExactChild('SIGKILL');
+          finish(null);
+        }, forceCloseMs);
+        owner.forceCloseTimer.unref?.();
+      }, terminateGraceMs);
+      owner.forceKillTimer.unref?.();
+    };
+
+    const retainOutput = (channel, chunk) => {
+      if (!owner.acceptingOutput || owner.settled) return;
+      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      const nextBytes = owner.retainedOutputBytes + buffer.length;
+      const nextChunks = owner.stdoutChunks.length + owner.stderrChunks.length + 1;
+      if (nextBytes > maxOutputBytes || nextChunks > MAX_CODEX_CLI_OUTPUT_CHUNKS) {
+        failAfterExactChildStops(Object.assign(
+          new Error(`Codex CLI status output exceeded its bounded retention budget.`),
+          {
+            code: 'codex-status-output-limit',
+            maxOutputBytes,
+            observedOutputBytes: nextBytes,
+            maxOutputChunks: MAX_CODEX_CLI_OUTPUT_CHUNKS,
+            observedOutputChunks: nextChunks
+          }
+        ));
+        return;
+      }
+      owner.retainedOutputBytes = nextBytes;
+      if (channel === 'stdout') {
+        owner.stdoutChunks.push(buffer);
+        owner.stdoutBytes += buffer.length;
+      } else {
+        owner.stderrChunks.push(buffer);
+        owner.stderrBytes += buffer.length;
+      }
+    };
+
+    function onStdoutData(chunk) {
+      retainOutput('stdout', chunk);
+    }
+
+    function onStderrData(chunk) {
+      retainOutput('stderr', chunk);
+    }
+
+    function onStdoutError(error) {
+      failAfterExactChildStops(error);
+    }
+
+    function onStderrError(error) {
+      failAfterExactChildStops(error);
+    }
+
+    function onChildError(error) {
+      failAfterExactChildStops(error);
+    }
+
+    function onChildClose(code) {
+      finish(code);
+    }
+
+    child.stdout.on('data', onStdoutData);
+    child.stdout.once('error', onStdoutError);
+    child.stderr.on('data', onStderrData);
+    child.stderr.once('error', onStderrError);
+    child.once('error', onChildError);
+    child.once('close', onChildClose);
+    owner.timeoutTimer = setTimeout(() => {
+      owner.timeoutTimer = null;
+      failAfterExactChildStops(Object.assign(
+        new Error('Codex CLI status check timed out.'),
+        { code: 'codex-status-timeout' }
+      ));
+    }, boundedTimeoutMs);
+    owner.timeoutTimer.unref?.();
+  });
+}
 
 function isTerminalStatus(status) {
   return ['completed', 'failed', 'cancelled'].includes(status);
@@ -371,13 +635,9 @@ export function createCodexAgentRuntime({
     return codexModulePromise;
   }
 
-  function cliPath() {
-    try {
-      return require.resolve('@openai/codex/bin/codex.js');
-    } catch {
-      return '';
-    }
-  }
+  function cliPath() {
+    return resolveBundledCodexCliPath();
+  }
 
   async function getStatus() {
     if (typeof injectedCodexStatus === 'function') return injectedCodexStatus();
@@ -531,6 +791,7 @@ export function createCodexAgentRuntime({
       run.status = 'running';
       run.updatedAt = new Date().toISOString();
       for (let attempt = 0; attempt < 2; attempt += 1) {
+        let turnCompleted = false;
         try {
           await prepareCodexHome({ preferGlobalAuth: attempt > 0 && run.authRecoveryRequested === true });
           reportProgress(run, 'thinking', attempt === 0 ? 'Codex is analyzing the request.' : 'Codex is retrying the request with a refreshed runtime.');
@@ -565,10 +826,27 @@ export function createCodexAgentRuntime({
               throw new Error(safeText(event.item?.error?.message, 800) || `LiveDesk tool ${safeText(event.item?.tool, 120) || 'call'} failed.`);
             }
             if (event.type === 'item.completed' && event.item?.type === 'agent_message') run.finalResponse = safeText(event.item.text, 4000);
-            if (event.type === 'turn.completed') run.status = 'completed';
+            if (event.type === 'turn.completed') turnCompleted = true;
             if (event.type === 'turn.failed') throw new Error(safeText(event.error?.message, 800) || 'Codex run failed.');
             if (event.type === 'error') throw new Error(safeText(event.message, 800) || 'Codex run failed.');
           }
+          if (!turnCompleted) {
+            throw new AgentRuntimeError(
+              'codex-incomplete-turn',
+              'Codex ended without a completed turn.',
+              { status: 502 }
+            );
+          }
+          if (!safeText(run.finalResponse, 4000)) {
+            throw new AgentRuntimeError(
+              'codex-empty-response',
+              'Codex completed without a final response.',
+              { status: 502 }
+            );
+          }
+          // Terminal state is externally observable. Publish it only after the
+          // complete event stream has drained and its final response is owned.
+          run.status = 'completed';
           break;
         } catch (error) {
           const normalized = normalizeCodexError(error);
@@ -589,7 +867,13 @@ export function createCodexAgentRuntime({
           await new Promise(resolve => setTimeout(resolve, 250));
         }
       }
-      if (run.status === 'running') run.status = 'completed';
+      if (run.status !== 'completed') {
+        throw new AgentRuntimeError(
+          'codex-incomplete-turn',
+          'Codex did not reach a completed terminal state.',
+          { status: 502 }
+        );
+      }
     } catch (error) {
       if (run.abortReason === 'timeout') {
         run.status = 'failed';