@love-moon/conductor-cli 0.2.19 → 0.2.21

package/src/daemon.js

@@ -11,15 +11,32 @@ import yaml from "js-yaml";
 import { ConductorWebSocketClient, ConductorConfig, loadConfig, ConfigFileNotFound } from "@love-moon/conductor-sdk";
 import { DaemonLogCollector } from "./log-collector.js";
 import { filterRuntimeSupportedAllowCliList, normalizeRuntimeBackendName } from "./runtime-backends.js";
+import {
+  PACKAGE_NAME,
+  fetchLatestVersion,
+  isNewerVersion,
+  detectPackageManager,
+  parseUpdateWindow,
+  isInUpdateWindow,
+  isManagedInstallPath,
+} from "./version-check.js";
 
 dotenv.config();
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
+const PACKAGE_ROOT = path.join(__dirname, "..");
 const moduleRequire = createRequire(import.meta.url);
-const CLI_PATH = path.resolve(__dirname, "..", "bin", "conductor-fire.js");
+const CLI_PATH = path.resolve(PACKAGE_ROOT, "bin", "conductor-fire.js");
 const DAEMON_LOG_DIR = path.join(os.homedir(), ".conductor", "logs");
 const DAEMON_LOG_PATH = path.join(DAEMON_LOG_DIR, "conductor-daemon.log");
+const CLI_VERSION = (() => {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(PACKAGE_ROOT, "package.json"), "utf-8")).version;
+  } catch {
+    return "unknown";
+  }
+})();
 const PLAN_LIMIT_MESSAGES = {
   manual_fire_active_task: "Free plan limit reached: only 1 active fire task is allowed.",
   app_active_task: "Free plan limit reached: only 1 active app task is allowed.",
@@ -28,6 +45,7 @@ const PLAN_LIMIT_MESSAGES = {
 const DEFAULT_TERMINAL_COLS = 120;
 const DEFAULT_TERMINAL_ROWS = 40;
 const DEFAULT_TERMINAL_RING_BUFFER_MAX_BYTES = 2 * 1024 * 1024;
+const DEFAULT_RTC_MODULE_CANDIDATES = ["@roamhq/wrtc", "wrtc"];
 let nodePtySpawnPromise = null;
 
 function appendDaemonLog(line) {
@@ -199,6 +217,16 @@ function normalizeOptionalString(value) {
   return normalized || null;
 }
 
+function normalizeStringArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value
+    .filter((entry) => typeof entry === "string")
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+}
+
 function normalizePositiveInt(value, fallback) {
   const parsed = Number.parseInt(String(value ?? ""), 10);
   if (Number.isFinite(parsed) && parsed > 0) {
@@ -207,6 +235,25 @@ function normalizePositiveInt(value, fallback) {
   return fallback;
 }
 
+function normalizeNonNegativeInt(value, fallback = null) {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  if (Number.isFinite(parsed) && parsed >= 0) {
+    return parsed;
+  }
+  return fallback;
+}
+
+function normalizeIsoTimestamp(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const normalized = value.trim();
+  if (!normalized) {
+    return null;
+  }
+  return Number.isNaN(Date.parse(normalized)) ? null : normalized;
+}
+
 function normalizeLaunchConfig(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return {};
@@ -309,6 +356,43 @@ export function startDaemon(config = {}, deps = {}) {
   // Get allow_cli_list from config
   const ALLOW_CLI_LIST = getAllowCliList(userConfig);
   const SUPPORTED_BACKENDS = Object.keys(ALLOW_CLI_LIST);
+  const fetchLatestVersionFn = deps.fetchLatestVersion || fetchLatestVersion;
+  const isNewerVersionFn = deps.isNewerVersion || isNewerVersion;
+  const detectPackageManagerFn = deps.detectPackageManager || detectPackageManager;
+  const parseUpdateWindowFn = deps.parseUpdateWindow || parseUpdateWindow;
+  const isInUpdateWindowFn = deps.isInUpdateWindow || isInUpdateWindow;
+  const isManagedInstallPathFn = deps.isManagedInstallPath || isManagedInstallPath;
+  const installedPackageRoot = deps.packageRoot || PACKAGE_ROOT;
+  const cliVersion = deps.cliVersion || CLI_VERSION;
+  const isBackgroundProcess = deps.isBackgroundProcess ?? !process.stdout.isTTY;
+  const autoUpdateForceLocal = parseBooleanEnv(process.env.CONDUCTOR_AUTO_UPDATE_FORCE_LOCAL);
+  const autoUpdateSupportedInstall =
+    autoUpdateForceLocal || isManagedInstallPathFn(installedPackageRoot);
+  const lockHandoffToken =
+    normalizeOptionalString(config.LOCK_HANDOFF_TOKEN) ||
+    normalizeOptionalString(process.env.CONDUCTOR_LOCK_HANDOFF_TOKEN);
+  const lockHandoffFromPid = normalizePositiveInt(
+    config.LOCK_HANDOFF_FROM_PID || process.env.CONDUCTOR_LOCK_HANDOFF_FROM_PID,
+    null,
+  );
+  const restartLauncherScript = normalizeOptionalString(config.RESTART_LAUNCHER_SCRIPT);
+  const restartLauncherArgs = normalizeStringArray(config.RESTART_LAUNCHER_ARGS);
+  const normalizedVersionCheckArgs = normalizeStringArray(config.VERSION_CHECK_ARGS);
+  const versionCheckScript =
+    normalizeOptionalString(config.VERSION_CHECK_SCRIPT) || restartLauncherScript;
+  const versionCheckArgs =
+    normalizedVersionCheckArgs.length > 0
+      ? normalizedVersionCheckArgs
+      : ["--version"];
+
+  // Auto-update configuration
+  const AUTO_UPDATE_ENABLED =
+    autoUpdateSupportedInstall &&
+    (process.env.CONDUCTOR_AUTO_UPDATE !== "false") &&
+    (userConfig.auto_update !== false);
+  const UPDATE_WINDOW = parseUpdateWindowFn(
+    process.env.CONDUCTOR_UPDATE_WINDOW || userConfig.update_window || "02:00-04:00"
+  );
 
   const spawnFn = deps.spawn || spawn;
   const mkdirSyncFn = deps.mkdirSync || fs.mkdirSync;
@@ -319,10 +403,14 @@ export function startDaemon(config = {}, deps = {}) {
   const renameSyncFn = deps.renameSync || fs.renameSync;
   const createWriteStreamFn = deps.createWriteStream || fs.createWriteStream;
   const fetchFn = deps.fetch || fetch;
+  const createRtcPeerConnection = deps.createRtcPeerConnection || null;
+  const importOptionalModule = deps.importOptionalModule || ((moduleName) => import(moduleName));
   const createWebSocketClient =
     deps.createWebSocketClient ||
     ((clientConfig, options) => new ConductorWebSocketClient(clientConfig, options));
   const createLogCollector = deps.createLogCollector || ((backendUrl) => new DaemonLogCollector(backendUrl));
+  const RTC_MODULE_CANDIDATES = resolveRtcModuleCandidates(process.env.CONDUCTOR_PTY_RTC_MODULES);
+  const RTC_DIRECT_DISABLED = parseBooleanEnv(process.env.CONDUCTOR_DISABLE_PTY_DIRECT_RTC);
   const PROJECT_PATH_LOOKUP_TIMEOUT_MS = parsePositiveInt(
     process.env.CONDUCTOR_PROJECT_PATH_LOOKUP_TIMEOUT_MS,
     1500,
@@ -368,6 +456,53 @@ export function startDaemon(config = {}, deps = {}) {
     DEFAULT_TERMINAL_RING_BUFFER_MAX_BYTES,
   );
 
+  const readLockState = () => {
+    const raw = String(readFileSyncFn(LOCK_FILE, "utf-8") || "").trim();
+    if (!raw) {
+      return null;
+    }
+
+    const pid = Number.parseInt(raw, 10);
+    if (!Number.isNaN(pid) && pid > 0) {
+      return {
+        pid,
+        handoffFromPid: null,
+        handoffToken: null,
+        handoffExpiresAt: null,
+      };
+    }
+
+    try {
+      const parsed = JSON.parse(raw);
+      const parsedPid = normalizePositiveInt(parsed?.pid, null);
+      const parsedHandoffFromPid = normalizePositiveInt(parsed?.handoff_from_pid, null);
+      return {
+        pid: parsedPid ?? parsedHandoffFromPid,
+        handoffFromPid: parsedHandoffFromPid,
+        handoffToken: normalizeOptionalString(parsed?.handoff_token),
+        handoffExpiresAt: normalizePositiveInt(parsed?.handoff_expires_at, null),
+      };
+    } catch {
+      return null;
+    }
+  };
+
+  const hasMatchingLockHandoff = (lockState) => {
+    if (!lockState || !lockHandoffToken || !lockHandoffFromPid) {
+      return false;
+    }
+    if (lockState.handoffToken !== lockHandoffToken) {
+      return false;
+    }
+    if (lockState.handoffFromPid !== lockHandoffFromPid) {
+      return false;
+    }
+    if (lockState.handoffExpiresAt && lockState.handoffExpiresAt < Date.now()) {
+      return false;
+    }
+    return true;
+  };
+
   try {
     mkdirSyncFn(WORKSPACE_ROOT, { recursive: true });
   } catch (err) {
@@ -378,44 +513,57 @@ export function startDaemon(config = {}, deps = {}) {
   const LOCK_FILE = path.join(WORKSPACE_ROOT, "daemon.pid");
   try {
     if (existsSyncFn(LOCK_FILE)) {
-      const pid = parseInt(readFileSyncFn(LOCK_FILE, "utf-8"), 10);
-      if (!Number.isNaN(pid)) {
+      const lockState = readLockState();
+      const pid = lockState?.pid;
+      if (pid) {
+        const handoffMatched = hasMatchingLockHandoff(lockState);
         try {
-          const alive = isProcessAlive(pid);
-          if (alive) {
-            if (config.FORCE) {
-              log(`Force enabled: stopping existing daemon PID ${pid}`);
-              try {
-                killFn(pid, "SIGTERM");
-              } catch (killErr) {
-                if (!killErr || killErr.code !== "ESRCH") {
-                  logError(`Failed to stop existing daemon PID ${pid}: ${killErr.message}`);
-                  return exitAndReturn(1);
+          if (handoffMatched) {
+            log(`Taking over daemon lock from PID ${pid} via handoff`);
+          } else {
+            const alive = isProcessAlive(pid);
+            if (alive) {
+              if (config.FORCE) {
+                log(`Force enabled: stopping existing daemon PID ${pid}`);
+                try {
+                  killFn(pid, "SIGTERM");
+                } catch (killErr) {
+                  if (!killErr || killErr.code !== "ESRCH") {
+                    logError(`Failed to stop existing daemon PID ${pid}: ${killErr.message}`);
+                    return exitAndReturn(1);
+                  }
                 }
-              }
-              try {
-                if (isProcessAlive(pid)) {
-                  logError(`Existing daemon PID ${pid} is still running; please stop it manually.`);
+                try {
+                  if (isProcessAlive(pid)) {
+                    logError(`Existing daemon PID ${pid} is still running; please stop it manually.`);
+                    return exitAndReturn(1);
+                  }
+                } catch (checkErr) {
+                  logError(`Failed to verify daemon PID ${pid}: ${checkErr.message}`);
                   return exitAndReturn(1);
                 }
-              } catch (checkErr) {
-                logError(`Failed to verify daemon PID ${pid}: ${checkErr.message}`);
+                log("Removing lock file after force stop");
+                unlinkSyncFn(LOCK_FILE);
+              } else {
+                logError(`Daemon already running with PID ${pid}`);
                 return exitAndReturn(1);
               }
-              log("Removing lock file after force stop");
-              unlinkSyncFn(LOCK_FILE);
             } else {
-              logError(`Daemon already running with PID ${pid}`);
-              return exitAndReturn(1);
+              log("Removing stale lock file");
+              unlinkSyncFn(LOCK_FILE);
             }
-          } else {
-            log("Removing stale lock file");
-            unlinkSyncFn(LOCK_FILE);
           }
         } catch (e) {
-          logError(`Daemon already running with PID ${pid} (access denied)`);
-          return exitAndReturn(1);
+          if (handoffMatched) {
+            log(`Taking over daemon lock from PID ${pid} via handoff`);
+          } else {
+            logError(`Daemon already running with PID ${pid} (access denied)`);
+            return exitAndReturn(1);
+          }
         }
+      } else {
+        log("Removing malformed lock file");
+        unlinkSyncFn(LOCK_FILE);
       }
     }
     writeFileSyncFn(LOCK_FILE, process.pid.toString());
@@ -427,8 +575,8 @@ export function startDaemon(config = {}, deps = {}) {
   const cleanupLock = () => {
     try {
       if (existsSyncFn(LOCK_FILE)) {
-        const pid = parseInt(readFileSyncFn(LOCK_FILE, "utf-8"), 10);
-        if (pid === process.pid) {
+        const lockState = readLockState();
+        if (lockState?.pid === process.pid) {
           unlinkSyncFn(LOCK_FILE);
         }
       }
@@ -437,6 +585,18 @@ export function startDaemon(config = {}, deps = {}) {
     }
   };
 
+  const writeLockHandoff = ({ handoffToken, handoffFromPid, handoffExpiresAt }) => {
+    writeFileSyncFn(
+      LOCK_FILE,
+      JSON.stringify({
+        pid: handoffFromPid,
+        handoff_from_pid: handoffFromPid,
+        handoff_token: handoffToken,
+        handoff_expires_at: handoffExpiresAt,
+      }),
+    );
+  };
+
   process.on("exit", cleanupLock);
   const signalExitCode = (signal) => (signal === "SIGINT" ? 130 : 143);
   const handleSignal = (signal) => {
@@ -503,6 +663,7 @@ export function startDaemon(config = {}, deps = {}) {
   let daemonShuttingDown = false;
   const activeTaskProcesses = new Map();
   const activePtySessions = new Map();
+  const activePtyRtcTransports = new Map();
   const suppressedExitStatusReports = new Set();
   const seenCommandRequestIds = new Set();
   let lastConnectedAt = null;
@@ -519,6 +680,16 @@ export function startDaemon(config = {}, deps = {}) {
   let watchdogLastPresenceMismatchAt = 0;
   let watchdogAwaitingHealthySignalAt = null;
   let watchdogTimer = null;
+
+  // --- Auto-update state ---
+  const VERSION_CHECK_INTERVAL_MS = 6 * 60 * 60 * 1000; // 6 hours
+  let lastVersionCheckAt = 0;
+  let latestKnownVersion = null;
+  let updateAvailable = false;
+  let autoUpdateInProgress = false;
+
+  let rtcImplementationPromise = null;
+  let rtcAvailabilityLogKey = null;
   const logCollector = createLogCollector(BACKEND_HTTP);
   const createPtyFn = deps.createPty || defaultCreatePty;
   const client = createWebSocketClient(sdkConfig, {
@@ -526,6 +697,7 @@ export function startDaemon(config = {}, deps = {}) {
       "x-conductor-host": AGENT_NAME,
       "x-conductor-backends": SUPPORTED_BACKENDS.join(","),
       "x-conductor-capabilities": "pty_task",
+      "x-conductor-version": cliVersion,
     },
     onConnected: ({ isReconnect, connectedAt } = { isReconnect: false, connectedAt: Date.now() }) => {
       wsConnected = true;
@@ -583,8 +755,15 @@ export function startDaemon(config = {}, deps = {}) {
     logError(`Failed to connect: ${err}`);
   });
 
+  if (!AUTO_UPDATE_ENABLED && autoUpdateSupportedInstall === false) {
+    log("[auto-update] Disabled for local/dev install; set CONDUCTOR_AUTO_UPDATE_FORCE_LOCAL=true to override");
+  }
+
   watchdogTimer = setInterval(() => {
     void runDaemonWatchdog();
+    // Auto-update checks (internally throttled)
+    void checkForUpdate().catch(() => {});
+    void tryAutoUpdate().catch(() => {});
   }, DAEMON_WATCHDOG_INTERVAL_MS);
   if (typeof watchdogTimer?.unref === "function") {
     watchdogTimer.unref();
@@ -742,6 +921,260 @@ export function startDaemon(config = {}, deps = {}) {
     }
   }
 
+  // ---------------------------------------------------------------------------
+  // Auto-update: periodic version check (P1) + safe-window update (P2)
+  // ---------------------------------------------------------------------------
+
+  const SEMVER_RE = /^\d+\.\d+\.\d+(-[\w.]+)?$/;
+
+  async function checkForUpdate() {
+    if (!AUTO_UPDATE_ENABLED || cliVersion === "unknown") return;
+    const now = Date.now();
+    if (now - lastVersionCheckAt < VERSION_CHECK_INTERVAL_MS) return;
+    lastVersionCheckAt = now;
+    try {
+      const latest = await fetchLatestVersionFn();
+      if (!latest || !SEMVER_RE.test(latest)) return; // reject malformed versions
+      if (isNewerVersionFn(latest, cliVersion)) {
+        if (latestKnownVersion !== latest) {
+          log(`[auto-update] New version available: ${cliVersion} -> ${latest}`);
+        }
+        latestKnownVersion = latest;
+        updateAvailable = true;
+      } else {
+        updateAvailable = false;
+        latestKnownVersion = latest;
+      }
+    } catch {
+      /* silent — non-critical */
+    }
+  }
+
+  const AUTO_UPDATE_COOLDOWN_MS = 60 * 60 * 1000; // 1 hour cooldown after failure
+  let lastAutoUpdateFailAt = 0;
+
+  function hasActiveTasks() {
+    return activeTaskProcesses.size > 0 || activePtySessions.size > 0;
+  }
+
+  async function tryAutoUpdate() {
+    if (!AUTO_UPDATE_ENABLED || !updateAvailable || !latestKnownVersion) return;
+    if (autoUpdateInProgress || daemonShuttingDown) return;
+    if (hasActiveTasks()) return;
+    if (!isInUpdateWindowFn(UPDATE_WINDOW)) return;
+    if (Date.now() - lastAutoUpdateFailAt < AUTO_UPDATE_COOLDOWN_MS) return;
+
+    autoUpdateInProgress = true;
+    log(`[auto-update] Starting: ${cliVersion} -> ${latestKnownVersion}`);
+    try {
+      await performAutoUpdate(latestKnownVersion);
+    } catch (err) {
+      logError(`[auto-update] Failed: ${err?.message || err}`);
+      lastAutoUpdateFailAt = Date.now();
+    } finally {
+      autoUpdateInProgress = false;
+    }
+  }
+
+  function runInstallCommand(pm, pkgSpec) {
+    return new Promise((resolve) => {
+      let cmd, args;
+      switch (pm) {
+        case "pnpm":
+          cmd = "pnpm";
+          args = ["add", "-g", pkgSpec];
+          break;
+        case "yarn":
+          cmd = "yarn";
+          args = ["global", "add", pkgSpec];
+          break;
+        default:
+          cmd = "npm";
+          args = ["install", "-g", pkgSpec];
+          break;
+      }
+      let stdout = "";
+      let stderr = "";
+      const child = spawnFn(cmd, args, {
+        stdio: ["ignore", "pipe", "pipe"],
+      });
+      const timer = setTimeout(() => {
+        try {
+          child.kill("SIGTERM");
+        } catch {
+          /* ignore */
+        }
+      }, 120_000);
+      child.stdout?.on("data", (d) => {
+        if (stdout.length < 4000) stdout += d.toString().slice(0, 2000);
+      });
+      child.stderr?.on("data", (d) => {
+        if (stderr.length < 4000) stderr += d.toString().slice(0, 2000);
+      });
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        resolve({ success: code === 0, code, stdout, stderr });
+      });
+      child.on("error", (err) => {
+        clearTimeout(timer);
+        resolve({ success: false, code: -1, stdout, stderr: err.message });
+      });
+    });
+  }
+
+  function runCommand(command, args, timeoutMs = 120_000) {
+    return new Promise((resolve) => {
+      let stdout = "";
+      let stderr = "";
+      const child = spawnFn(command, args, {
+        stdio: ["ignore", "pipe", "pipe"],
+        env: { ...process.env },
+      });
+      const timer = setTimeout(() => {
+        try {
+          child.kill("SIGTERM");
+        } catch {
+          /* ignore */
+        }
+      }, timeoutMs);
+      child.stdout?.on("data", (chunk) => {
+        if (stdout.length < 4000) stdout += chunk.toString().slice(0, 2000);
+      });
+      child.stderr?.on("data", (chunk) => {
+        if (stderr.length < 4000) stderr += chunk.toString().slice(0, 2000);
+      });
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        resolve({ success: code === 0, code, stdout, stderr });
+      });
+      child.on("error", (err) => {
+        clearTimeout(timer);
+        resolve({ success: false, code: -1, stdout, stderr: err.message || String(err) });
+      });
+    });
+  }
+
+  async function readInstalledCliVersion() {
+    const commandAttempts = versionCheckScript
+      ? [{
+          command: process.execPath,
+          args: [versionCheckScript, ...versionCheckArgs],
+        }]
+      : [{
+          command: "conductor",
+          args: ["--version"],
+        }];
+
+    for (const attempt of commandAttempts) {
+      const commandResult = await runCommand(attempt.command, attempt.args, 15_000);
+      const combinedOutput = `${commandResult.stdout}\n${commandResult.stderr}`.trim();
+      const match = combinedOutput.match(/conductor version ([^\s]+)/);
+      if (match?.[1]) {
+        return match[1];
+      }
+    }
+
+    let pkgPath;
+    try {
+      pkgPath = moduleRequire.resolve(`${PACKAGE_NAME}/package.json`);
+    } catch {
+      pkgPath = path.join(installedPackageRoot, "package.json");
+    }
+    const newPkg = JSON.parse(readFileSyncFn(pkgPath, "utf-8"));
+    return newPkg.version || null;
+  }
+
+  async function performAutoUpdate(targetVersion) {
+    const pm = detectPackageManagerFn({
+      launcherPath: restartLauncherScript || versionCheckScript,
+      packageRoot: installedPackageRoot,
+    });
+    const pkgSpec = `${PACKAGE_NAME}@${targetVersion}`;
+    log(`[auto-update] Installing ${pkgSpec} via ${pm}...`);
+
+    // Step 1: install
+    const result = await runInstallCommand(pm, pkgSpec);
+    if (!result.success) {
+      throw new Error(
+        `Install failed (exit ${result.code}): ${(result.stderr || result.stdout).slice(0, 200)}`
+      );
+    }
+
+    // Step 2: re-check active tasks — a task may have arrived during the install
+    if (hasActiveTasks()) {
+      log("[auto-update] Active tasks appeared during install; aborting restart (will retry later)");
+      return;
+    }
+
+    // Step 3: verify installed version using the globally resolved CLI entry point.
+    try {
+      const installedVersion = await readInstalledCliVersion();
+      if (installedVersion !== targetVersion) {
+        throw new Error(
+          `Version mismatch after install: expected ${targetVersion}, got ${installedVersion}`
+        );
+      }
+    } catch (verifyErr) {
+      throw new Error(`Version verification failed: ${verifyErr?.message || verifyErr}`);
+    }
+
+    log(`[auto-update] Verified ${targetVersion}. Restarting daemon...`);
+
+    let logFd = null;
+    if (isBackgroundProcess) {
+      if (!restartLauncherScript) {
+        throw new Error("Missing daemon restart launcher script");
+      }
+      try {
+        mkdirSyncFn(DAEMON_LOG_DIR, { recursive: true });
+      } catch {
+        /* ignore */
+      }
+      logFd = fs.openSync(DAEMON_LOG_PATH, "a");
+    }
+
+    // Step 4: graceful shutdown
+    await shutdownDaemon("auto-update");
+
+    // Step 5: re-spawn (only in background/nohup mode)
+    if (isBackgroundProcess) {
+      const handoffToken = `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+      const handoffExpiresAt = Date.now() + 15_000;
+      try {
+        writeLockHandoff({
+          handoffToken,
+          handoffFromPid: process.pid,
+          handoffExpiresAt,
+        });
+        const child = spawnFn(process.execPath, [restartLauncherScript, ...restartLauncherArgs], {
+          detached: true,
+          stdio: ["ignore", logFd, logFd],
+          env: {
+            ...process.env,
+            CONDUCTOR_LOCK_HANDOFF_TOKEN: handoffToken,
+            CONDUCTOR_LOCK_HANDOFF_FROM_PID: String(process.pid),
+            CONDUCTOR_LOCK_HANDOFF_EXPIRES_AT: String(handoffExpiresAt),
+          },
+        });
+        child.unref();
+        log(`[auto-update] New daemon spawned (PID ${child.pid})`);
+      } catch (error) {
+        cleanupLock();
+        exitFn(1);
+        throw new Error(`Restart failed after shutdown: ${error?.message || error}`);
+      } finally {
+        if (typeof logFd === "number") {
+          fs.closeSync(logFd);
+        }
+      }
+    } else {
+      log(
+        `[auto-update] Updated to ${targetVersion}. Foreground mode — please restart the daemon.`
+      );
+    }
+    exitFn(0);
+  }
+
   const getActiveTaskIds = () => [
     ...new Set([...activeTaskProcesses.keys(), ...activePtySessions.keys()]),
   ];
@@ -908,6 +1341,285 @@ export function startDaemon(config = {}, deps = {}) {
     });
   }
 
+  function sendPtyTransportStatus(payload) {
+    return client.sendJson({
+      type: "pty_transport_status",
+      payload,
+    });
+  }
+
+  function rejectCreateTaskDuringShutdown(payload, { sendAck = true } = {}) {
+    const taskId = payload?.task_id ? String(payload.task_id) : "";
+    const projectId = payload?.project_id ? String(payload.project_id) : "";
+    const requestId = payload?.request_id ? String(payload.request_id) : "";
+    log(`Rejecting create_task for ${taskId || "unknown"}: daemon is shutting down`);
+    if (sendAck) {
+      sendAgentCommandAck({
+        requestId,
+        taskId,
+        eventType: "create_task",
+        accepted: false,
+      }).catch(() => {});
+    }
+    if (!taskId || !projectId) {
+      return;
+    }
+    client
+      .sendJson({
+        type: "task_status_update",
+        payload: {
+          task_id: taskId,
+          project_id: projectId,
+          status: "KILLED",
+          summary: "daemon shutting down",
+        },
+      })
+      .catch((err) => {
+        logError(`Failed to report shutdown rejection for ${taskId}: ${err?.message || err}`);
+      });
+  }
+
+  function rejectCreatePtyTaskDuringShutdown(payload, { sendAck = true } = {}) {
+    const taskId = payload?.task_id ? String(payload.task_id) : "";
+    const projectId = payload?.project_id ? String(payload.project_id) : "";
+    const ptySessionId = payload?.pty_session_id ? String(payload.pty_session_id) : null;
+    const requestId = payload?.request_id ? String(payload.request_id) : "";
+    log(`Rejecting create_pty_task for ${taskId || "unknown"}: daemon is shutting down`);
+    if (sendAck) {
+      sendAgentCommandAck({
+        requestId,
+        taskId,
+        eventType: "create_pty_task",
+        accepted: false,
+      }).catch(() => {});
+    }
+    sendTerminalEvent("terminal_error", {
+      task_id: taskId || undefined,
+      project_id: projectId || undefined,
+      pty_session_id: ptySessionId,
+      message: "daemon shutting down",
+    }).catch((err) => {
+      logError(`Failed to report PTY shutdown rejection for ${taskId || "unknown"}: ${err?.message || err}`);
+    });
+  }
+
+  function sendPtyTransportSignal(payload) {
+    return client.sendJson({
+      type: "pty_transport_signal",
+      payload,
+    });
+  }
+
+  function logRtcAvailabilityOnce(key, message) {
+    if (rtcAvailabilityLogKey === key) {
+      return;
+    }
+    rtcAvailabilityLogKey = key;
+    log(message);
+  }
+
+  async function resolveRtcImplementation() {
+    if (RTC_DIRECT_DISABLED) {
+      logRtcAvailabilityOnce(
+        "disabled",
+        "PTY direct RTC runtime disabled by CONDUCTOR_DISABLE_PTY_DIRECT_RTC=1; relay fallback only",
+      );
+      return null;
+    }
+
+    if (createRtcPeerConnection) {
+      logRtcAvailabilityOnce("ready:deps", "PTY direct RTC runtime ready via injected peer connection");
+      return {
+        source: "deps.createRtcPeerConnection",
+        createPeerConnection: (...args) => createRtcPeerConnection(...args),
+      };
+    }
+
+    if (typeof globalThis.RTCPeerConnection === "function") {
+      logRtcAvailabilityOnce("ready:global", "PTY direct RTC runtime ready via globalThis.RTCPeerConnection");
+      return {
+        source: "globalThis.RTCPeerConnection",
+        createPeerConnection: (...args) => new globalThis.RTCPeerConnection(...args),
+      };
+    }
+
+    if (!rtcImplementationPromise) {
+      rtcImplementationPromise = (async () => {
+        for (const moduleName of RTC_MODULE_CANDIDATES) {
+          try {
+            const mod = await importOptionalModule(moduleName);
+            const PeerConnectionCtor =
+              mod?.RTCPeerConnection ||
+              mod?.default?.RTCPeerConnection ||
+              mod?.default;
+            if (typeof PeerConnectionCtor === "function") {
+              return {
+                source: moduleName,
+                createPeerConnection: (...args) => new PeerConnectionCtor(...args),
+              };
+            }
+          } catch {
+            // Try next implementation.
+          }
+        }
+        return null;
+      })();
+    }
+
+    const rtc = await rtcImplementationPromise;
+    if (rtc) {
+      logRtcAvailabilityOnce(`ready:${rtc.source}`, `PTY direct RTC runtime ready via ${rtc.source}`);
+      return rtc;
+    }
+
+    logRtcAvailabilityOnce(
+      "unavailable",
+      `PTY direct RTC runtime unavailable; install optional dependency ${DEFAULT_RTC_MODULE_CANDIDATES[0]} or keep relay fallback`,
+    );
+    return null;
+  }
+
+  function cleanupPtyRtcTransport(taskId, expectedSessionId = null) {
+    const current = activePtyRtcTransports.get(taskId);
+    if (!current) {
+      return;
+    }
+    if (expectedSessionId && current.sessionId !== expectedSessionId) {
+      return;
+    }
+    try {
+      current.channel?.close?.();
+    } catch {}
+    try {
+      current.peer?.close?.();
+    } catch {}
+    activePtyRtcTransports.delete(taskId);
+  }
+
+  async function startPtyRtcNegotiation(taskId, sessionId, connectionId, offerDescription) {
+    const record = activePtySessions.get(taskId);
+    if (!record) {
+      return { ok: false, reason: "terminal_session_not_found" };
+    }
+
+    const rtc = await resolveRtcImplementation();
+    if (!rtc) {
+      return { ok: false, reason: "direct_transport_not_supported" };
+    }
+
+    cleanupPtyRtcTransport(taskId);
+
+    try {
+      const peer = rtc.createPeerConnection();
+      const transport = {
+        taskId,
+        sessionId,
+        connectionId,
+        peer,
+        channel: null,
+      };
+      activePtyRtcTransports.set(taskId, transport);
+
+      peer.ondatachannel = (event) => {
+        transport.channel = event?.channel || null;
+        if (transport.channel) {
+          transport.channel.onmessage = (messageEvent) => {
+            try {
+              const raw =
+                typeof messageEvent?.data === "string"
+                  ? messageEvent.data
+                  : Buffer.isBuffer(messageEvent?.data)
+                    ? messageEvent.data.toString("utf8")
+                    : String(messageEvent?.data ?? "");
+              const parsed = JSON.parse(raw);
+              handleDirectTransportPayload(taskId, sessionId, connectionId, parsed);
+            } catch (error) {
+              logError(`Failed to handle PTY direct channel message for ${taskId}: ${error?.message || error}`);
+            }
+          };
+          transport.channel.onopen = () => {
+            sendPtyTransportStatus({
+              task_id: taskId,
+              session_id: sessionId,
+              connection_id: connectionId,
+              transport_state: "direct",
+              transport_policy: "direct_preferred",
+              writer_connection_id: connectionId,
+              direct_candidate: true,
+            }).catch((err) => {
+              logError(`Failed to report direct PTY transport status for ${taskId}: ${err?.message || err}`);
+            });
+          };
+          transport.channel.onclose = () => {
+            sendPtyTransportStatus({
+              task_id: taskId,
+              session_id: sessionId,
+              connection_id: connectionId,
+              transport_state: "fallback_relay",
+              transport_policy: "direct_preferred",
+              writer_connection_id: connectionId,
+              direct_candidate: false,
+              reason: "direct_channel_closed",
+            }).catch((err) => {
+              logError(`Failed to report PTY transport fallback for ${taskId}: ${err?.message || err}`);
+            });
+            cleanupPtyRtcTransport(taskId, sessionId);
+          };
+        }
+      };
+
+      peer.onicecandidate = (event) => {
+        if (!event?.candidate) {
+          return;
+        }
+        sendPtyTransportSignal({
+          task_id: taskId,
+          session_id: sessionId,
+          connection_id: connectionId,
+          signal_type: "ice_candidate",
+          candidate: typeof event.candidate.toJSON === "function" ? event.candidate.toJSON() : event.candidate,
+        }).catch((err) => {
+          logError(`Failed to report PTY ICE candidate for ${taskId}: ${err?.message || err}`);
+        });
+      };
+
+      await peer.setRemoteDescription({
+        type: "offer",
+        sdp: offerDescription.sdp,
+      });
+      const answer = await peer.createAnswer();
+      await peer.setLocalDescription(answer);
+
+      await sendPtyTransportSignal({
+        task_id: taskId,
+        session_id: sessionId,
+        connection_id: connectionId,
+        signal_type: "answer",
+        description: {
+          type: answer.type,
+          sdp: answer.sdp,
+        },
+      });
+      await sendPtyTransportStatus({
+        task_id: taskId,
+        session_id: sessionId,
+        connection_id: connectionId,
+        transport_state: "negotiating",
+        transport_policy: "direct_preferred",
+        writer_connection_id: connectionId,
+        direct_candidate: true,
+      });
+
+      return { ok: true };
+    } catch (error) {
+      cleanupPtyRtcTransport(taskId, sessionId);
+      return {
+        ok: false,
+        reason: error?.message || "rtc_negotiation_failed",
+      };
+    }
+  }
+
   function resolvePtyLaunchSpec(launchConfig, fallbackCwd) {
     const normalizedLaunchConfig = normalizeLaunchConfig(launchConfig);
     const entrypointType =
@@ -1025,6 +1737,54 @@ export function startDaemon(config = {}, deps = {}) {
     return record.outputSeq;
   }
 
+  function sendDirectPtyPayload(taskId, payload) {
+    const transport = activePtyRtcTransports.get(taskId);
+    const channel = transport?.channel;
+    if (!channel || channel.readyState !== "open" || typeof channel.send !== "function") {
+      return false;
+    }
+    try {
+      channel.send(JSON.stringify(payload));
+      return true;
+    } catch (error) {
+      logError(`Failed to send PTY direct payload for ${taskId}: ${error?.message || error}`);
+      if (transport) {
+        sendPtyTransportStatus({
+          task_id: taskId,
+          session_id: transport.sessionId,
+          connection_id: transport.connectionId,
+          transport_state: "fallback_relay",
+          transport_policy: "direct_preferred",
+          writer_connection_id: transport.connectionId,
+          direct_candidate: false,
+          reason: "direct_channel_send_failed",
+        }).catch((err) => {
+          logError(`Failed to report PTY direct send fallback for ${taskId}: ${err?.message || err}`);
+        });
+      }
+      cleanupPtyRtcTransport(taskId);
+      return false;
+    }
+  }
+
+  function handleDirectTransportPayload(taskId, sessionId, connectionId, payload) {
+    const transport = activePtyRtcTransports.get(taskId);
+    if (
+      !transport ||
+      transport.sessionId !== sessionId ||
+      transport.connectionId !== connectionId
+    ) {
+      return;
+    }
+    if (payload?.type === "terminal_input" && payload.payload) {
+      handleTerminalInput(payload.payload);
+      return;
+    }
+    if (payload?.type === "terminal_resize" && payload.payload) {
+      handleTerminalResize(payload.payload);
+    }
+  }
+
   function attachPtyStreamHandlers(taskId, record) {
     const writeLogChunk = (chunk) => {
       if (record.logStream) {
@@ -1035,13 +1795,30 @@ export function startDaemon(config = {}, deps = {}) {
     record.pty.onData((data) => {
       writeLogChunk(data);
       const seq = bufferTerminalOutput(record, data);
-      sendTerminalEvent("terminal_output", {
+      const latencySample = record.pendingLatencySample
+        ? {
+            client_input_seq: record.pendingLatencySample.clientInputSeq ?? undefined,
+            client_sent_at: record.pendingLatencySample.clientSentAt ?? undefined,
+            server_received_at: record.pendingLatencySample.serverReceivedAt ?? undefined,
+            daemon_received_at: record.pendingLatencySample.daemonReceivedAt,
+            first_output_at: new Date().toISOString(),
+            daemon_input_to_first_output_ms: Math.max(0, Date.now() - record.pendingLatencySample.daemonReceivedAtMs),
+          }
+        : undefined;
+      record.pendingLatencySample = null;
+      const outputPayload = {
         task_id: taskId,
         project_id: record.projectId,
         pty_session_id: record.ptySessionId,
         seq,
         data,
-      }).catch((err) => {
+        ...(latencySample ? { latency_sample: latencySample } : {}),
+      };
+      sendDirectPtyPayload(taskId, {
+        type: "terminal_output",
+        payload: outputPayload,
+      });
+      sendTerminalEvent("terminal_output", outputPayload).catch((err) => {
         logError(`Failed to report terminal_output for ${taskId}: ${err?.message || err}`);
       });
     });
@@ -1050,6 +1827,7 @@ export function startDaemon(config = {}, deps = {}) {
       if (record.stopForceKillTimer) {
         clearTimeout(record.stopForceKillTimer);
       }
+      cleanupPtyRtcTransport(taskId);
       activePtySessions.delete(taskId);
       if (record.logStream) {
         const ts = new Date().toLocaleString("sv-SE", { timeZone: "Asia/Shanghai" }).replace(" ", "T");
@@ -1113,6 +1891,11 @@ export function startDaemon(config = {}, deps = {}) {
       return;
     }
 
+    if (daemonShuttingDown) {
+      rejectCreatePtyTaskDuringShutdown(payload);
+      return;
+    }
+
     if (activeTaskProcesses.has(taskId) || activePtySessions.has(taskId)) {
       log(`Duplicate create_pty_task ignored for ${taskId}: task already active`);
       sendAgentCommandAck({
@@ -1125,6 +1908,10 @@ export function startDaemon(config = {}, deps = {}) {
     }
 
     let boundPath = await getProjectLocalPath(projectId);
+    if (daemonShuttingDown) {
+      rejectCreatePtyTaskDuringShutdown(payload);
+      return;
+    }
     let taskDir = normalizeOptionalString(launchConfig.cwd) || boundPath;
     if (!taskDir) {
       const now = new Date();
@@ -1217,6 +2004,20 @@ export function startDaemon(config = {}, deps = {}) {
         cwd: launchSpec.cwd,
         env,
       });
+      if (daemonShuttingDown) {
+        try {
+          if (typeof pty?.kill === "function") {
+            pty.kill("SIGTERM");
+          }
+        } catch (killError) {
+          logError(`Failed to stop PTY task ${taskId} during shutdown: ${killError?.message || killError}`);
+        }
+        if (logStream) {
+          logStream.end();
+        }
+        rejectCreatePtyTaskDuringShutdown(payload, { sendAck: false });
+        return;
+      }
       const resolvedLogPath = path.join(taskDir, "conductor-terminal.log");
 
       const startedAt = new Date().toISOString();
@@ -1235,6 +2036,7 @@ export function startDaemon(config = {}, deps = {}) {
         outputSeq: 0,
         ringBuffer: [],
         ringBufferByteLength: 0,
+        pendingLatencySample: null,
         stopForceKillTimer: null,
       };
       activePtySessions.set(taskId, record);
@@ -1322,6 +2124,13 @@ export function startDaemon(config = {}, deps = {}) {
     if (!record || typeof record.pty.write !== "function") {
       return;
     }
+    record.pendingLatencySample = {
+      clientInputSeq: normalizeNonNegativeInt(payload?.client_input_seq ?? payload?.clientInputSeq, null),
+      clientSentAt: normalizeIsoTimestamp(payload?.client_sent_at ?? payload?.clientSentAt),
+      serverReceivedAt: normalizeIsoTimestamp(payload?.server_received_at ?? payload?.serverReceivedAt),
+      daemonReceivedAt: new Date().toISOString(),
+      daemonReceivedAtMs: Date.now(),
+    };
     record.pty.write(data);
   }
 
@@ -1337,6 +2146,124 @@ export function startDaemon(config = {}, deps = {}) {
     // PTY sessions stay alive without viewers. Detach is currently a no-op.
   }
 
+  async function handlePtyTransportSignal(payload) {
+    const taskId = payload?.task_id ? String(payload.task_id) : "";
+    const sessionId = payload?.session_id ? String(payload.session_id) : "";
+    const connectionId = payload?.connection_id ? String(payload.connection_id) : "";
+    const signalType = payload?.signal_type ? String(payload.signal_type) : "";
+    if (!taskId || !connectionId || !signalType) {
+      return;
+    }
+
+    const record = activePtySessions.get(taskId);
+    const description =
+      payload?.description && typeof payload.description === "object" && !Array.isArray(payload.description)
+        ? payload.description
+        : null;
+    const candidate =
+      payload?.candidate && typeof payload.candidate === "object" && !Array.isArray(payload.candidate)
+        ? payload.candidate
+        : null;
+
+    if (signalType === "ice_candidate") {
+      if (!sessionId) {
+        return;
+      }
+      const transport = activePtyRtcTransports.get(taskId);
+      if (
+        transport &&
+        transport.sessionId === sessionId &&
+        transport.connectionId === connectionId &&
+        typeof transport.peer?.addIceCandidate === "function" &&
+        candidate
+      ) {
+        try {
+          await transport.peer.addIceCandidate(candidate);
+        } catch (err) {
+          logError(`Failed to apply PTY ICE candidate for ${taskId}: ${err?.message || err}`);
+        }
+      }
+      return;
+    }
+
+    if (signalType === "revoke") {
+      const transport = activePtyRtcTransports.get(taskId);
+      if (transport && transport.connectionId === connectionId) {
+        cleanupPtyRtcTransport(taskId);
+      }
+      return;
+    }
+
+    if (signalType === "offer" && description?.type === "offer" && typeof description.sdp === "string") {
+      if (!sessionId) {
+        return;
+      }
+      const negotiation = await startPtyRtcNegotiation(taskId, sessionId, connectionId, description);
+      if (negotiation.ok) {
+        return;
+      }
+      const reason = negotiation.reason || (record ? "direct_transport_not_supported" : "terminal_session_not_found");
+      sendPtyTransportSignal({
+        task_id: taskId,
+        session_id: sessionId,
+        connection_id: connectionId,
+        signal_type: "answer_placeholder",
+        description: {
+          type: "answer",
+          mode: "placeholder",
+          reason,
+        },
+      }).catch((err) => {
+        logError(`Failed to report pty_transport_signal for ${taskId}: ${err?.message || err}`);
+      });
+      sendPtyTransportStatus({
+        task_id: taskId,
+        session_id: sessionId,
+        connection_id: connectionId,
+        transport_state: "fallback_relay",
+        transport_policy: "relay_only",
+        writer_connection_id: connectionId,
+        direct_candidate: false,
+        reason,
+      }).catch((err) => {
+        logError(`Failed to report pty_transport_status for ${taskId}: ${err?.message || err}`);
+      });
+      return;
+    }
+
+    const reason = record ? "direct_transport_not_supported" : "terminal_session_not_found";
+    if (signalType === "direct_request") {
+      if (!sessionId) {
+        return;
+      }
+      sendPtyTransportSignal({
+        task_id: taskId,
+        session_id: sessionId,
+        connection_id: connectionId,
+        signal_type: "answer_placeholder",
+        description: {
+          type: "answer",
+          mode: "placeholder",
+          reason,
+        },
+      }).catch((err) => {
+        logError(`Failed to report pty_transport_signal for ${taskId}: ${err?.message || err}`);
+      });
+      sendPtyTransportStatus({
+        task_id: taskId,
+        session_id: sessionId,
+        connection_id: connectionId,
+        transport_state: "fallback_relay",
+        transport_policy: "relay_only",
+        writer_connection_id: connectionId,
+        direct_candidate: false,
+        reason,
+      }).catch((err) => {
+        logError(`Failed to report pty_transport_status for ${taskId}: ${err?.message || err}`);
+      });
+    }
+  }
+
   function handleEvent(event) {
     const receivedAt = Date.now();
     lastInboundAt = receivedAt;
@@ -1357,6 +2284,17 @@ export function startDaemon(config = {}, deps = {}) {
       return;
     }
 
+    if (daemonShuttingDown) {
+      if (event.type === "create_task") {
+        rejectCreateTaskDuringShutdown(event.payload);
+        return;
+      }
+      if (event.type === "create_pty_task") {
+        rejectCreatePtyTaskDuringShutdown(event.payload);
+        return;
+      }
+    }
+
     if (event.type === "create_task") {
       handleCreateTask(event.payload);
       return;
@@ -1385,6 +2323,10 @@ export function startDaemon(config = {}, deps = {}) {
       handleTerminalDetach(event.payload);
       return;
     }
+    if (event.type === "pty_transport_signal") {
+      void handlePtyTransportSignal(event.payload);
+      return;
+    }
     if (event.type === "collect_logs") {
       void handleCollectLogs(event.payload);
     }
@@ -1516,6 +2458,9 @@ export function startDaemon(config = {}, deps = {}) {
       clearTimeout(activeRecord.stopForceKillTimer);
       activeRecord.stopForceKillTimer = null;
     }
+    if (ptyRecord) {
+      cleanupPtyRtcTransport(taskId);
+    }
 
     if (processRecord?.child) {
       try {
@@ -1651,6 +2596,11 @@ export function startDaemon(config = {}, deps = {}) {
       return;
     }
 
+    if (daemonShuttingDown) {
+      rejectCreateTaskDuringShutdown(payload);
+      return;
+    }
+
     const existingTaskRecord = activeTaskProcesses.get(taskId);
     if (existingTaskRecord?.child) {
       log(
@@ -1718,6 +2668,10 @@ export function startDaemon(config = {}, deps = {}) {
 
     // Check if project has a bound local path for this daemon
     const boundPath = await getProjectLocalPath(projectId);
+    if (daemonShuttingDown) {
+      rejectCreateTaskDuringShutdown(payload, { sendAck: false });
+      return;
+    }
     let taskDir;
     let logPath;
     let runTimestampPart = null;
@@ -1961,6 +2915,7 @@ export function startDaemon(config = {}, deps = {}) {
         if (record?.stopForceKillTimer) {
           clearTimeout(record.stopForceKillTimer);
         }
+        cleanupPtyRtcTransport(taskId);
         try {
           if (typeof record.pty?.kill === "function") {
             record.pty.kill("SIGTERM");
@@ -2044,6 +2999,25 @@ function parsePositiveInt(value, fallback) {
   return fallback;
 }
 
+function parseBooleanEnv(value) {
+  if (typeof value !== "string") {
+    return false;
+  }
+  const normalized = value.trim().toLowerCase();
+  return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
+}
+
+function resolveRtcModuleCandidates(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    return [...DEFAULT_RTC_MODULE_CANDIDATES];
+  }
+  const candidates = value
+    .split(",")
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+  return candidates.length > 0 ? [...new Set(candidates)] : [...DEFAULT_RTC_MODULE_CANDIDATES];
+}
+
 function formatDisconnectDiagnostics(event) {
   const parts = [];
   const reason = typeof event?.reason === "string" && event.reason.trim()