@love-moon/conductor-cli 0.8.0 → 0.10.0

package/src/ai-manager-handlers.js

@@ -5,7 +5,7 @@
 import { AiManager } from "@love-moon/ai-sdk";
 
 const VALID_ACTIONS = new Set(["status", "quota", "list_accounts", "switch_account"]);
-const BASE_QUOTA_TOOLS = ["codex", "claude", "kimi", "copilot"];
+const BASE_QUOTA_TOOLS = ["codex", "claude", "kimi", "copilot", "dsh"];
 
 /**
  * @param {object} opts
@@ -23,7 +23,7 @@ export function createAiManagerHandlers(opts = {}) {
       manager.getCurrentCodexAccount().catch(() => null),
     ]);
     const network = {};
-    const tools = ["codex", "claude", "kimi", "copilot"];
+    const tools = [...BASE_QUOTA_TOOLS];
     await Promise.all(
       tools.map(async (tool) => {
         if (install[tool]?.installed) {
@@ -70,6 +70,9 @@ export function createAiManagerHandlers(opts = {}) {
     addJob("copilot", () => manager.getCopilotQuota({
       forceRefresh,
     }));
+    addJob("dsh", () => manager.getDshQuota({
+      forceRefresh,
+    }));
     const externalBackends = pickExternalQuotaBackends(args);
     for (const backend of externalBackends) {
       if (!tools.has(backend)) {

package/src/daemon.js

@@ -30,6 +30,11 @@ import {
   createCustomCommandHandlers,
   handleCustomCommandsRequest,
 } from "./custom-command-handlers.js";
+import {
+  REMOTE_EXEC_CAPABILITY,
+  createRemoteExecHandlers,
+  handleRemoteExecRequest,
+} from "./remote-exec-handlers.js";
 import { resolveResumeContext } from "./fire/resume.js";
 import {
   filterRuntimeSupportedAllowCliList,
@@ -213,6 +218,32 @@ function getFireTmuxModeEnabled(userConfig) {
   return false;
 }
 
+// Whether this host will accept `remote-exec`. Unlike `pty_task` (gated on a
+// node-pty probe) and `custom_commands` (opt-in per script), remote exec would
+// otherwise be unconditional, leaving a shared CI box or a root-owned daemon no
+// way to decline. Defaults to enabled to match the other daemon capabilities.
+//
+// Resolution order:
+//   1. CONDUCTOR_REMOTE_EXEC env var ("1"/"true"/"on" enable, "0"/"false"/"off" disable)
+//   2. remote_exec boolean in the resolved Conductor config.yaml
+//   3. Default: true
+function getRemoteExecEnabled(userConfig) {
+  const rawEnv = process.env.CONDUCTOR_REMOTE_EXEC;
+  if (typeof rawEnv === "string" && rawEnv.trim()) {
+    const normalized = rawEnv.trim().toLowerCase();
+    if (normalized === "1" || normalized === "true" || normalized === "on" || normalized === "yes") {
+      return true;
+    }
+    if (normalized === "0" || normalized === "false" || normalized === "off" || normalized === "no") {
+      return false;
+    }
+  }
+  if (userConfig && typeof userConfig === "object" && userConfig.remote_exec === false) {
+    return false;
+  }
+  return true;
+}
+
 function normalizePlanLimitType(limitType) {
   if (typeof limitType !== "string") {
     return null;
@@ -322,6 +353,57 @@ function serializeRuntimeBackendMap(runtimeBackendMap) {
     .join(",");
 }
 
+// Backends whose install/auth health can be probed via the AI manager. Others
+// (external providers) are left out of the advertised health map so the web
+// runtime preflight fails open for them.
+const RUNTIME_HEALTH_TOOLS = new Set(["codex", "claude", "copilot", "kimi", "dsh"]);
+
+function runtimeHealthToolForBackend(backend, runtimeBackendMap) {
+  const normalized = String(backend || "").trim().toLowerCase();
+  if (RUNTIME_HEALTH_TOOLS.has(normalized)) {
+    return normalized;
+  }
+  const runtime = String(runtimeBackendMap?.[normalized] || "").trim().toLowerCase();
+  return RUNTIME_HEALTH_TOOLS.has(runtime) ? runtime : null;
+}
+
+function serializeRuntimeHealth(runtimeHealth) {
+  if (!runtimeHealth || typeof runtimeHealth !== "object") {
+    return "";
+  }
+  return Object.entries(runtimeHealth)
+    .filter(([backend, state]) => backend && state)
+    .sort(([left], [right]) => left.localeCompare(right))
+    .map(([backend, state]) => `${backend}=${state}`)
+    .join(",");
+}
+
+// Best-effort per-backend runtime health for the web runtime preflight. Only a
+// cheap install probe (which/--version) runs, once at startup. We advertise
+// only a POSITIVE `ready` confirmation: a supported backend whose default-name
+// `which` probe fails is very likely resolved via a custom or absolute path
+// (allow_cli_list, or a systemd PATH that differs from the login shell) and is
+// still runnable, so reporting it as "missing" would be an unreliable false
+// negative that could wrongly block task creation. Omitting it lets the web
+// preflight fail open for that backend.
+async function computeAdvertisedRuntimeHealth(manager, supportedBackends, runtimeBackendMap) {
+  if (!manager || typeof manager.checkInstallAll !== "function") {
+    return {};
+  }
+  const install = await manager.checkInstallAll();
+  const runtimeHealth = {};
+  for (const backend of supportedBackends || []) {
+    const tool = runtimeHealthToolForBackend(backend, runtimeBackendMap);
+    if (!tool) {
+      continue;
+    }
+    if (install?.[tool]?.installed) {
+      runtimeHealth[String(backend).trim().toLowerCase()] = "ready";
+    }
+  }
+  return runtimeHealth;
+}
+
 async function defaultCreatePty(command, args, options) {
   if (!nodePtySpawnPromise) {
     const spawnHelperInfo = ensureNodePtySpawnHelperExecutable();
@@ -799,6 +881,7 @@ export function startDaemon(config = {}, deps = {}) {
   // warning and silently fall back to direct spawn rather than failing every
   // create_task with ENOENT.
   const FIRE_TMUX_MODE_ENABLED = getFireTmuxModeEnabled(userConfig);
+  const remoteExecEnabled = getRemoteExecEnabled(userConfig);
 
   // Get allow_cli_list from config
   const RAW_ALLOW_CLI_LIST = getRawAllowCliList(userConfig);
@@ -2196,11 +2279,19 @@ export function startDaemon(config = {}, deps = {}) {
 
       if (linkStat) {
         if (!linkStat.isSymbolicLink()) {
-          throw new Error(
-            `worktree symlink destination already exists and is not a symlink: ${linkPath}. ` +
-              `Refusing to replace it because it may hold real data — remove it manually, ` +
-              `or drop "${configuredPath}" from worktree.symlink in .conductor/settings.yaml.`,
+          // A real file/dir at the destination means something materialised
+          // data inside the worktree (e.g. `pnpm install` replaced the
+          // node_modules link with a real directory). It may hold real data,
+          // so never clobber it — but throwing here made every task in this
+          // worktree permanently un-restartable. Keep the local copy and skip
+          // the link; remove the path manually (or drop the entry from
+          // worktree.symlink) to restore sharing with the project workspace.
+          logError(
+            `[worktree] skipping symlink for ${configuredPath}: destination already exists and ` +
+              `is not a symlink: ${linkPath}. Keeping the local copy — remove it manually to ` +
+              `restore sharing via worktree.symlink in .conductor/settings.yaml.`,
           );
+          continue;
         }
         // Compare the link's TARGET, not whether that target resolves. A link
         // that already points at the right place is correct even when the
@@ -2934,8 +3025,14 @@ export function startDaemon(config = {}, deps = {}) {
     "project_agents_registry",
     "restart_daemon",
     "refresh_session_inplace",
+    "task_attachments_v1",
     CUSTOM_COMMANDS_CAPABILITY,
   ];
+  if (remoteExecEnabled) {
+    advertisedCapabilities.push(REMOTE_EXEC_CAPABILITY);
+  } else {
+    log("[remote-exec] Disabled by config (remote_exec: false); capability not advertised");
+  }
   if (ptyTaskCapabilityEnabled) {
     advertisedCapabilities.push("pty_task", "terminal_snapshot");
   }
@@ -2944,6 +3041,9 @@ export function startDaemon(config = {}, deps = {}) {
   }
   const aiManagerHandlers = createAiManagerHandlers({ configPath: effectiveConfigPath });
   const customCommandHandlers = createCustomCommandHandlers({ configPath: effectiveConfigPath });
+  const remoteExecHandlers = remoteExecEnabled
+    ? createRemoteExecHandlers({ defaultWorkspace: homeDir })
+    : null;
 
   const client = createWebSocketClient(sdkConfig, {
     extraHeaders,
@@ -3036,6 +3136,28 @@ export function startDaemon(config = {}, deps = {}) {
     if (typeof client?.setExtraHeaders === "function") {
       client.setExtraHeaders(extraHeaders);
     }
+
+    // Advertise best-effort runtime health so the backend can reject a task
+    // whose backend is configured but cannot start (CLI missing/not signed in)
+    // before creating any timeline activity. Fully additive and guarded: any
+    // failure just omits the header and the preflight fails open.
+    try {
+      const runtimeHealth = await computeAdvertisedRuntimeHealth(
+        aiManagerHandlers?.manager,
+        SUPPORTED_BACKENDS,
+        SUPPORTED_BACKEND_RUNTIME_MAP,
+      );
+      const serializedRuntimeHealth = serializeRuntimeHealth(runtimeHealth);
+      if (serializedRuntimeHealth) {
+        extraHeaders["x-conductor-runtime-health"] = serializedRuntimeHealth;
+        if (typeof client?.setExtraHeaders === "function") {
+          client.setExtraHeaders(extraHeaders);
+        }
+      }
+    } catch (error) {
+      logError(`Failed to probe runtime health: ${error?.message || error}`);
+    }
+
     if (daemonShuttingDown) {
       return;
     }
@@ -5171,6 +5293,40 @@ export function startDaemon(config = {}, deps = {}) {
         logError(`Unhandled custom_commands_request failure: ${error?.message || error}`);
       });
     }
+    if (event.type === "remote_exec_request") {
+      // Remote exec is the only execution path that leaves no Task row and no
+      // per-run log file, so record it here — otherwise a run is invisible
+      // once the daemon restarts. argv is deliberately omitted: it routinely
+      // carries secrets and this log is collected by `collect_logs`.
+      const execArgs = event?.payload?.args && typeof event.payload.args === "object" ? event.payload.args : {};
+      log(
+        `[remote-exec] ${event?.payload?.action || "?"} command=${execArgs.command || ""} ` +
+          `argc=${Array.isArray(execArgs.args) ? execArgs.args.length : 0} cwd=${execArgs.workspace || "<default>"}`,
+      );
+      // Fail fast rather than letting the caller wait out its full timeout —
+      // it has no other way to learn that this daemon will never answer.
+      const rejectReason = !remoteExecHandlers
+        ? "remote exec is disabled on this daemon (remote_exec: false)"
+        : daemonShuttingDown
+          ? "daemon is shutting down"
+          : "";
+      if (rejectReason) {
+        void client
+          .sendJson({
+            type: "remote_exec_response",
+            payload: {
+              request_id: event?.payload?.request_id ? String(event.payload.request_id) : "",
+              action: event?.payload?.action ? String(event.payload.action) : "",
+              error: rejectReason,
+            },
+          })
+          .catch(() => {});
+        return;
+      }
+      handleRemoteExecRequest(client, remoteExecHandlers, event.payload).catch((error) => {
+        logError(`Unhandled remote_exec_request failure: ${error?.message || error}`);
+      });
+    }
     if (event.type === "restart_daemon") {
       void handleRestartDaemon(event.payload).catch((error) => {
         logError(`Unhandled restart_daemon failure: ${error?.message || error}`);
@@ -6218,6 +6374,10 @@ export function startDaemon(config = {}, deps = {}) {
         PWD: taskDir,
         CONDUCTOR_PROJECT_ID: projectId,
         CONDUCTOR_TASK_ID: taskId,
+        // Fire derives its own stable host identity from the owning daemon plus
+        // the task. Passing the resolved name keeps that identity meaningful
+        // even when the daemon was named through the config file.
+        CONDUCTOR_DAEMON_NAME: AGENT_NAME,
         CONDUCTOR_LAUNCHED_BY_DAEMON: "1",
         ...(cliCommand ? { CONDUCTOR_CLI_COMMAND: cliCommand } : {}),
       };
@@ -6732,7 +6892,11 @@ export function startDaemon(config = {}, deps = {}) {
         resolvedResumeCwd = await resolveRestartCwd({
           taskId: normalizedTargetTaskId,
           projectId: normalizedProjectId,
-          backendType: effectiveBackend,
+          // A fork starts a fresh target-backend session, but its workspace
+          // still belongs to the source task. Resolve the source session in
+          // its own provider namespace; target + source session id is not a
+          // meaningful pair for cross-backend handoff.
+          backendType: sourceBackendType,
           launchConfig: targetLaunchConfig,
           sessionId: normalizedSourceSessionId,
           sourceSessionFilePath: sourceSessionFilePath ? String(sourceSessionFilePath) : "",
@@ -6920,6 +7084,7 @@ export function startDaemon(config = {}, deps = {}) {
       PWD: taskDir,
       CONDUCTOR_PROJECT_ID: normalizedProjectId,
       CONDUCTOR_TASK_ID: normalizedTargetTaskId,
+      CONDUCTOR_DAEMON_NAME: AGENT_NAME,
       CONDUCTOR_LAUNCHED_BY_DAEMON: "1",
       ...(cliCommand ? { CONDUCTOR_CLI_COMMAND: cliCommand } : {}),
     };