@love-moon/conductor-cli 0.7.7 → 0.9.0

package/bin/conductor.js

@@ -14,7 +14,8 @@
  *   serve-ai - Start an OpenAI-compatible local AI server
  *   project  - Manage Conductor projects (list/show/create/...)
  *   issue    - Manage issues (list/show/create/update/start/done)
- *   task     - Manage tasks (list/show/send/messages/schedule)
+ *   task     - Manage tasks (create/list/show/send/messages/schedule)
+ *   remote-exec - Run a command on another daemon's host
  */
 
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -50,6 +51,7 @@ export function runConductorCli(args = argv, deps = {}) {
     "project",
     "issue",
     "task",
+    "remote-exec",
   ];
 
   if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
@@ -134,7 +136,8 @@ Subcommands:
   serve-ai  Start an OpenAI-compatible local AI server
   project   Manage Conductor projects (list/show/create/...)
   issue     Manage issues (list/show/create/update/start/done)
-  task      Manage tasks (list/show/send/messages/schedule)
+  task      Manage tasks (create/list/show/send/messages/schedule)
+  remote-exec Run a command on another daemon's host
 
 Options:
   -h, --help     Show this help message
@@ -156,8 +159,10 @@ Examples:
   conductor update
   conductor project list
   conductor issue create --title "Refactor module" --priority P2
+  conductor task create --title "Refactor module" --prompt "Extract the parser" --backend codex
   conductor task send <task-id> "please add a unit test"
   conductor task schedule create <task-id> "follow up" --delay 10m
+  conductor remote-exec --target ubuntu --workspace /home/duino/ws/holomotion ls .
 
 For subcommand-specific help:
   conductor fire --help
@@ -171,6 +176,7 @@ For subcommand-specific help:
   conductor project --help
   conductor issue --help
   conductor task --help
+  conductor remote-exec --help
 
 Version: ${pkgJson.version}
 `);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.7.7",
-  "gitCommitId": "26b2dbb",
+  "version": "0.9.0",
+  "gitCommitId": "606e5a6",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/lovemoon-ai/conductor.git"
@@ -24,8 +24,8 @@
     "test": "node --test test/*.test.js"
   },
   "dependencies": {
-    "@love-moon/ai-sdk": "0.7.7",
-    "@love-moon/conductor-sdk": "0.7.7",
+    "@love-moon/ai-sdk": "0.9.0",
+    "@love-moon/conductor-sdk": "0.9.0",
     "@github/copilot-sdk": "^0.3.0",
     "chrome-launcher": "^1.2.1",
     "chrome-remote-interface": "^0.33.0",
@@ -38,7 +38,7 @@
   },
   "optionalDependencies": {
     "@roamhq/wrtc": "^0.10.0",
-    "@love-moon/chat-web": "0.7.7"
+    "@love-moon/chat-web": "0.9.0"
   },
   "pnpm": {
     "onlyBuiltDependencies": [

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;
@@ -799,6 +830,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);
@@ -1843,6 +1875,14 @@ export function startDaemon(config = {}, deps = {}) {
     "# (svg/png/jpg/gif/webp/ico/avif) relative to this .conductor/ directory.",
     "# Remove this line to use the default folder icon.",
     "",
+    "# Optional agent registry used by the task-composer worker/reviewer picker.",
+    "# Agent docs are workspace-relative paths; backend is optional.",
+    "# agents:",
+    "#   feature-dev:",
+    "#     doc: claw/agents/feature-dev.md",
+    "#     description: Implements features end to end.",
+    "#     backend: codex",
+    "",
     "worktree:",
     "  sync_branch: false",
     "  sync_submodules: true",
@@ -1856,6 +1896,13 @@ export function startDaemon(config = {}, deps = {}) {
   ].join("\n");
 
   const MAX_PROJECT_ICON_IMAGE_BYTES = 128 * 1024;
+  const MAX_PROJECT_AGENT_ENTRIES = 64;
+  const MAX_PROJECT_AGENT_NAME_LENGTH = 64;
+  const MAX_PROJECT_AGENT_DOC_LENGTH = 512;
+  const MAX_PROJECT_AGENT_DESCRIPTION_LENGTH = 512;
+  const MAX_PROJECT_AGENT_BACKEND_LENGTH = 64;
+  const PROJECT_AGENT_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+  const PROJECT_AGENT_BACKEND_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
   const PROJECT_ICON_MIME_BY_EXTENSION = {
     ".svg": "image/svg+xml",
     ".png": "image/png",
@@ -1954,6 +2001,118 @@ export function startDaemon(config = {}, deps = {}) {
     return null;
   }
 
+  function normalizeProjectAgentSetting(name, value) {
+    const normalizedName = normalizeOptionalString(name);
+    if (
+      !normalizedName ||
+      normalizedName.length > MAX_PROJECT_AGENT_NAME_LENGTH ||
+      !PROJECT_AGENT_NAME_RE.test(normalizedName)
+    ) {
+      return null;
+    }
+
+    let docValue = null;
+    let descriptionValue = null;
+    let backendValue = null;
+    if (typeof value === "string") {
+      docValue = value;
+    } else if (value && typeof value === "object" && !Array.isArray(value)) {
+      docValue = value.doc ?? value.path;
+      descriptionValue = value.description;
+      backendValue = value.backend;
+    } else {
+      return null;
+    }
+
+    const doc = normalizeOptionalString(docValue);
+    if (
+      !doc ||
+      doc.length > MAX_PROJECT_AGENT_DOC_LENGTH ||
+      path.isAbsolute(doc) ||
+      /^[A-Za-z]:[\\/]/.test(doc) ||
+      /^[/\\]{2}/.test(doc)
+    ) {
+      return null;
+    }
+    const normalizedDoc = path.posix.normalize(doc.split("\\").join("/"));
+    if (normalizedDoc === ".." || normalizedDoc.startsWith("../")) {
+      return null;
+    }
+
+    const description = normalizeOptionalString(descriptionValue);
+    const backend = normalizeOptionalString(backendValue)?.toLowerCase() || null;
+    return {
+      name: normalizedName,
+      doc,
+      description:
+        description && description.length <= MAX_PROJECT_AGENT_DESCRIPTION_LENGTH
+          ? description
+          : null,
+      backend:
+        backend &&
+        backend.length <= MAX_PROJECT_AGENT_BACKEND_LENGTH &&
+        PROJECT_AGENT_BACKEND_RE.test(backend)
+          ? backend
+          : null,
+    };
+  }
+
+  function normalizeProjectAgentsSetting(agentsNode) {
+    if (!agentsNode || typeof agentsNode !== "object") {
+      return [];
+    }
+    const result = [];
+    const seen = new Set();
+    const push = (entry) => {
+      if (
+        entry &&
+        result.length < MAX_PROJECT_AGENT_ENTRIES &&
+        !seen.has(entry.name)
+      ) {
+        seen.add(entry.name);
+        result.push(entry);
+      }
+    };
+
+    if (Array.isArray(agentsNode)) {
+      for (const item of agentsNode) {
+        if (!item || typeof item !== "object" || Array.isArray(item)) {
+          continue;
+        }
+        const keys = Object.keys(item);
+        if (keys.length === 1) {
+          push(normalizeProjectAgentSetting(keys[0], item[keys[0]]));
+        } else if (Object.prototype.hasOwnProperty.call(item, "name")) {
+          push(normalizeProjectAgentSetting(item.name, item));
+        }
+      }
+      return result;
+    }
+
+    for (const [name, value] of Object.entries(agentsNode)) {
+      push(normalizeProjectAgentSetting(name, value));
+    }
+    return result;
+  }
+
+  function readProjectAgentsSetting(projectWorkspacePath) {
+    for (const settingsPath of getProjectSettingsCandidates(projectWorkspacePath)) {
+      if (!existsSyncFn(settingsPath)) {
+        continue;
+      }
+      try {
+        const parsed = yaml.load(readFileSyncFn(settingsPath, "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+          return [];
+        }
+        return normalizeProjectAgentsSetting(parsed.agents);
+      } catch {
+        return [];
+      }
+    }
+    return [];
+  }
+
   function readProjectWorktreeSettings(projectWorkspacePath) {
     for (const settingsPath of getProjectSettingsCandidates(projectWorkspacePath)) {
       if (!existsSyncFn(settingsPath)) {
@@ -2069,11 +2228,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
@@ -2804,10 +2971,17 @@ export function startDaemon(config = {}, deps = {}) {
   };
   const advertisedCapabilities = [
     "project_path_validation",
+    "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");
   }
@@ -2816,6 +2990,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,
@@ -5027,6 +5204,11 @@ export function startDaemon(config = {}, deps = {}) {
     }
     if (event.type === "validate_project_path") {
       void handleValidateProjectPath(event.payload);
+      return;
+    }
+    if (event.type === "get_project_agents") {
+      void handleGetProjectAgents(event.payload);
+      return;
     }
     if (event.type === "ai_manager_request") {
       handleAiManagerRequest(client, aiManagerHandlers, event.payload).catch((error) => {
@@ -5038,6 +5220,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}`);
@@ -5132,6 +5348,7 @@ export function startDaemon(config = {}, deps = {}) {
       lastCommitAt: null,
       fileCount: null,
       icon: null,
+      agents: [],
       error: null,
       errorCode: null,
       validatedAt,
@@ -5186,6 +5403,7 @@ export function startDaemon(config = {}, deps = {}) {
               ? snapshot.fileCount
               : null,
           icon: readProjectIconSetting(effectiveWorkspace),
+          agents: readProjectAgentsSetting(effectiveWorkspace),
         };
       }
     } catch (error) {
@@ -5210,6 +5428,7 @@ export function startDaemon(config = {}, deps = {}) {
           git_remote_url: result.gitRemoteUrl,
           file_count: result.fileCount,
           icon: result.icon,
+          agents: result.agents,
           error: result.error,
           error_code: result.errorCode,
           validated_at: result.validatedAt,
@@ -5220,6 +5439,69 @@ export function startDaemon(config = {}, deps = {}) {
     }
   }
 
+  async function handleGetProjectAgents(payload) {
+    const requestId = payload?.request_id ? String(payload.request_id).trim() : "";
+    const rawWorkspacePath = payload?.workspace_path ? String(payload.workspace_path).trim() : "";
+    const resolvedAt = new Date().toISOString();
+
+    if (!requestId || !rawWorkspacePath) {
+      logError(`Invalid get_project_agents payload: ${JSON.stringify(payload)}`);
+      return;
+    }
+
+    let result = {
+      workspacePath: null,
+      agents: [],
+      error: null,
+      errorCode: null,
+    };
+    try {
+      const resolvedPath = path.resolve(rawWorkspacePath);
+      if (!existsSyncFn(resolvedPath)) {
+        result = {
+          ...result,
+          error: `Workspace path does not exist on daemon ${AGENT_NAME}: ${rawWorkspacePath}`,
+          errorCode: "workspace_not_found",
+        };
+      } else if (!statSyncFn(resolvedPath).isDirectory()) {
+        result = {
+          ...result,
+          error: `Workspace path is not a directory on daemon ${AGENT_NAME}: ${rawWorkspacePath}`,
+          errorCode: "workspace_not_directory",
+        };
+      } else {
+        result = {
+          ...result,
+          workspacePath: resolvedPath,
+          agents: readProjectAgentsSetting(resolvedPath),
+        };
+      }
+    } catch (error) {
+      result = {
+        ...result,
+        error: `Failed to read project agents on daemon ${AGENT_NAME}: ${error?.message || error}`,
+        errorCode: "project_agents_read_failed",
+      };
+    }
+
+    try {
+      await client.sendJson({
+        type: "project_agents_resolved",
+        payload: {
+          request_id: requestId,
+          daemon_host: AGENT_NAME,
+          workspace_path: result.workspacePath,
+          agents: result.agents,
+          error: result.error,
+          error_code: result.errorCode,
+          resolved_at: resolvedAt,
+        },
+      });
+    } catch (error) {
+      logError(`Failed to report project_agents_resolved for ${rawWorkspacePath}: ${error?.message || error}`);
+    }
+  }
+
   function stopActiveTaskProcess(
     taskId,
     {
@@ -6019,6 +6301,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 } : {}),
       };
@@ -6533,7 +6819,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) : "",
@@ -6721,6 +7011,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 } : {}),
     };

package/src/entity-helpers.js

@@ -192,8 +192,14 @@ export async function resolveProject(apis, options = {}) {
   if (!apis.projects || typeof apis.projects.resolveProject !== "function") {
     throw new Error("ProjectsApi.resolveProject is not available in conductor-sdk");
   }
+  const explicitProject = String(options.project ?? "").trim();
+  if (explicitProject) {
+    if (typeof apis.projects.getProject !== "function") {
+      throw new Error("ProjectsApi.getProject is not available in conductor-sdk");
+    }
+    return apis.projects.getProject(explicitProject);
+  }
   return apis.projects.resolveProject({
-    project: options.project,
     env: options.env || process.env,
     cwd: options.cwd || process.cwd(),
   });
@@ -332,11 +338,30 @@ export function emitDryRun(stream, json, payload) {
   }
 }
 
+/**
+ * Pull a human-readable reason out of a backend error payload. Backend routes
+ * respond with `{ error }` (occasionally `{ message }`), which the SDK attaches
+ * to BackendApiError.details. Surfacing it turns an opaque "Backend responded
+ * with 409" into the actual cause (e.g. "Project daemon X is offline").
+ */
+function backendErrorDetail(error) {
+  const details = error && typeof error === "object" ? error.details : null;
+  if (!details) return null;
+  if (typeof details === "string") return details.trim() || null;
+  if (typeof details === "object") {
+    const reason = details.error ?? details.message;
+    if (typeof reason === "string" && reason.trim()) return reason.trim();
+  }
+  return null;
+}
+
 /**
  * Translate an unknown error into a printable + exit-coded form.
  */
 export function reportError(consoleErr, error) {
   const message = error instanceof Error ? error.message : String(error);
-  consoleErr.error(`Error: ${message}`);
+  const detail = backendErrorDetail(error);
+  const line = detail && detail !== message ? `${message}: ${detail}` : message;
+  consoleErr.error(`Error: ${line}`);
   return exitCodeForError(error);
 }