@love-moon/conductor-cli 0.13.3 → 0.15.0

package/src/daemon.js

@@ -40,9 +40,11 @@ import {
 } from "./custom-command-handlers.js";
 import {
   REMOTE_EXEC_CAPABILITY,
+  REMOTE_EXEC_RUN_ID_CAPABILITY,
   createRemoteExecHandlers,
   handleRemoteExecRequest,
 } from "./remote-exec-handlers.js";
+import { REMOTE_WORKTREE_ENV, remoteWorktreeFireEnv } from "./remote/mcp-launch.js";
 import {
   REMOTE_FILE_CAPABILITY,
   createRemoteFileHandlers,
@@ -703,7 +705,9 @@ export function buildFireSpawnArgs({ selectedBackend, initialContent, launchConf
   const prefill = typeof initialContent === "string" ? initialContent : "";
   const effectivePrefill = prefill || goalObjective;
   if (effectivePrefill) {
-    args.push("--prefill", effectivePrefill);
+    // `=` form: as a separate argv entry, yargs reads content that starts with
+    // "-" (a markdown list, "--model ...") as a new flag and drops it.
+    args.push(`--prefill=${effectivePrefill}`);
   }
   const resumeSessionId =
     normalizeOptionalString(launchConfig?.resumeSessionId) ||
@@ -789,6 +793,10 @@ export async function collectBackendSessions({
           cwd: normalizeOptionalString(entry?.cwd),
           title: normalizeOptionalString(entry?.title),
           updated_at: Number.isFinite(entry?.updatedAt) ? new Date(entry.updatedAt).toISOString() : null,
+          first_user_message: normalizeOptionalString(entry?.preview?.firstUserMessage),
+          first_reply: normalizeOptionalString(entry?.preview?.firstReply),
+          last_message: normalizeOptionalString(entry?.preview?.lastMessage?.text),
+          last_message_role: normalizeOptionalString(entry?.preview?.lastMessage?.role),
         });
       }
     } catch (error) {
@@ -889,6 +897,7 @@ const PTY_TASK_SCOPED_ENV_KEYS = [
   "CONDUCTOR_PTY_SESSION_ID",
   "CONDUCTOR_LAUNCHED_BY_DAEMON",
   "CONDUCTOR_RESUME_CWD",
+  REMOTE_WORKTREE_ENV,
 ];
 
 // Task-scoped env vars a Fire must NEVER inherit from anywhere but this
@@ -3883,14 +3892,19 @@ export function startDaemon(config = {}, deps = {}) {
     "project_agents_registry",
     "restart_daemon",
     "refresh_session_inplace",
+    "restart_first_message",
     "persistent_round_v1",
     "task_attachments_v1",
+    // RFC 0041: this CLI can run a global-backend task's AI here — it drives
+    // another daemon over `conductor remote` and binds the remote_* MCP tools
+    // to a remoteWorkspace as well as a remoteWorktree.
+    "global_backend_v1",
     "backend_session_list",
     CUSTOM_COMMANDS_CAPABILITY,
     UPDATE_DAEMON_CAPABILITY,
   ];
   if (remoteExecEnabled) {
-    advertisedCapabilities.push(REMOTE_EXEC_CAPABILITY);
+    advertisedCapabilities.push(REMOTE_EXEC_CAPABILITY, REMOTE_EXEC_RUN_ID_CAPABILITY);
   } else {
     log("[remote-exec] Disabled by config (remote_exec: false); capability not advertised");
   }
@@ -5780,6 +5794,9 @@ export function startDaemon(config = {}, deps = {}) {
     let taskDir =
       normalizeOptionalString(launchConfig.cwd) ||
       boundPath;
+    // No project path: the shell starts in HOME; the scratch dir below only
+    // holds the terminal log.
+    const shellCwd = taskDir || homeDir;
     if (!taskDir) {
       const now = new Date();
       const dayDir = path.join(WORKSPACE_ROOT, formatWorkspaceDate(now));
@@ -5805,7 +5822,7 @@ export function startDaemon(config = {}, deps = {}) {
 
     let launchSpec;
     try {
-      launchSpec = resolvePtyLaunchSpec(launchConfig, taskDir);
+      launchSpec = resolvePtyLaunchSpec(launchConfig, shellCwd);
     } catch (error) {
       logError(`Failed to resolve PTY launch config for ${taskId}: ${error?.message || error}`);
       sendAgentCommandAck({
@@ -5834,7 +5851,7 @@ export function startDaemon(config = {}, deps = {}) {
 
     const env = buildPtyTaskEnv(process.env, launchSpec.env);
 
-    const logPath = path.join(launchSpec.cwd, "conductor-terminal.log");
+    const logPath = path.join(taskDir, "conductor-terminal.log");
     let logStream;
     try {
       logStream = createWriteStreamFn(logPath, { flags: "a" });
@@ -5870,7 +5887,6 @@ export function startDaemon(config = {}, deps = {}) {
         rejectCreatePtyTaskDuringShutdown(payload, { sendAck: false });
         return;
       }
-      const resolvedLogPath = path.join(taskDir, "conductor-terminal.log");
 
       const startedAt = new Date().toISOString();
       const record = {
@@ -5879,7 +5895,8 @@ export function startDaemon(config = {}, deps = {}) {
         ptySessionId,
         projectId,
         taskDir,
-        logPath: resolvedLogPath,
+        cwd: launchSpec.cwd,
+        logPath,
         logStream,
         cols: launchSpec.cols,
         rows: launchSpec.rows,
@@ -5900,7 +5917,7 @@ export function startDaemon(config = {}, deps = {}) {
         project_id: projectId,
         pty_session_id: ptySessionId,
         pid: Number.isInteger(pty?.pid) ? pty.pid : null,
-        cwd: taskDir,
+        cwd: launchSpec.cwd,
         shell: launchSpec.shell,
         cols: launchSpec.cols,
         rows: launchSpec.rows,
@@ -6107,7 +6124,7 @@ export function startDaemon(config = {}, deps = {}) {
       project_id: record.projectId,
       pty_session_id: record.ptySessionId,
       pid: Number.isInteger(record.pty?.pid) ? record.pty.pid : null,
-      cwd: record.taskDir,
+      cwd: record.cwd,
       shell: record.shell,
       cols: record.cols,
       rows: record.rows,
@@ -7808,6 +7825,8 @@ export function startDaemon(config = {}, deps = {}) {
         // backend (dsh/copilot) would see e.g. `claude --model opus` here and
         // mis-apply its flags. Fire treats "" as unset.
         CONDUCTOR_CLI_COMMAND: cliCommand,
+        // RFC 0040: lets fire give the AI tools bound to the remote worktree.
+        ...remoteWorktreeFireEnv(launchConfig),
       };
       if (AGENT_TOKEN) {
         env.CONDUCTOR_AGENT_TOKEN = AGENT_TOKEN;
@@ -8101,6 +8120,7 @@ export function startDaemon(config = {}, deps = {}) {
       source_session_file_path: sourceSessionFilePath,
       target_backend_type: targetBackendType,
       resume_context_url: resumeContextUrlRaw,
+      initial_content: initialContentRaw,
       request_id: requestIdRaw,
     } = payload || {};
 
@@ -8538,9 +8558,15 @@ export function startDaemon(config = {}, deps = {}) {
     if (isForkMode) {
       // Fork mode starts a brand-new session on the target backend; no --resume.
       // The prior conversation is delivered as a plain-text URL via the prompt
-      // so the target backend fetches it on its own.
-      args.push("--");
-      args.push(resumeHandoffPrompt);
+      // so the target backend fetches it on its own — unless the user set their
+      // own first message, which replaces it. That one goes through --prefill
+      // (string-typed) so fire does not coerce a numeric message like "0.10".
+      const customFirstMessage = normalizeOptionalString(initialContentRaw);
+      if (customFirstMessage) {
+        args.push(`--prefill=${customFirstMessage}`, "--");
+      } else {
+        args.push("--", resumeHandoffPrompt);
+      }
     } else {
       if (shouldResumeSession) {
         args.push("--resume", resolvedResumeSessionId);
@@ -8560,6 +8586,7 @@ export function startDaemon(config = {}, deps = {}) {
       // gets an explicit `-e CONDUCTOR_CLI_COMMAND=` that overrides any stale
       // value in the tmux SERVER's global environment (see create_task).
       CONDUCTOR_CLI_COMMAND: cliCommand,
+      ...remoteWorktreeFireEnv(targetLaunchConfig),
     };
     env.CONDUCTOR_RESUME_CWD = resolvedResumeCwd;
     if (AGENT_TOKEN) {

package/src/remote/client.js

@@ -112,7 +112,7 @@ export async function withRetry(fn, {
     } catch (error) {
       lastError = error;
       // An aborted transfer is the caller's own deadline firing, not a blip.
-      if (error?.name === "AbortError" || !retryable(error)) throw error;
+      if (error?.name === "AbortError" || !(await retryable(error))) throw error;
       if (attempt === attempts - 1) break;
       await sleep(baseDelayMs * 2 ** attempt);
     }

package/src/remote/cp.js

@@ -385,7 +385,7 @@ async function downloadChunks({
   }, { sleep });
 }
 
-async function uploadFile(ctx) {
+export async function uploadFile(ctx) {
   const { config, target, localPath, remotePath, fetchImpl, consoleImpl, signal, quiet } = ctx;
   const resolvedLocal = path.resolve(expandHome(localPath));
 
@@ -466,7 +466,7 @@ async function uploadFile(ctx) {
   return { ...delivered, transferId, direction: "up", sizeBytes: stat.size, sha256 };
 }
 
-async function downloadFile(ctx) {
+export async function downloadFile(ctx) {
   const { config, target, remotePath, localPath, fetchImpl, consoleImpl, signal, quiet } = ctx;
   const basePath = `/api/agents/${encodeURIComponent(target)}/files`;
 

package/src/remote/exec.js

@@ -6,6 +6,7 @@
  * or globs are actually wanted.
  */
 
+import { randomUUID } from "node:crypto";
 import process from "node:process";
 
 import {
@@ -13,6 +14,7 @@ import {
   UsageError,
   callApi,
   delay,
+  isRetryable,
   loadCliConfig,
   parseTimeoutMs as parseSharedTimeoutMs,
   withRetry,
@@ -25,12 +27,10 @@ const POLL_INTERVAL_MS = 1_000;
 /** How long a single request may block server-side before we switch to polling. */
 const POST_WAIT_MS = 10_000;
 /**
- * A 429 means the per-user in-flight cap (8) is full — nothing was started, so
- * retrying is safe. Six attempts at 500ms doubling waits out ~15s, longer than
- * one saturating POST can block (POST_WAIT_MS). Nothing else is retried here:
- * a 5xx may have started the command already, and a second POST would run it twice.
+ * Six attempts at 500ms doubling wait out ~15s, longer than one saturating POST
+ * can block (POST_WAIT_MS). What is safe to retry is decided in `execRemote`.
  */
-const POST_RETRY = { attempts: 6, retryable: (error) => error?.status === 429 };
+const POST_ATTEMPTS = 6;
 const INTERRUPT_SIGNALS = ["SIGINT", "SIGTERM"];
 
 const VALUE_FLAGS = new Map([
@@ -233,16 +233,31 @@ export async function execRemote(config, target, command, options = {}) {
   const basePath = `/api/agents/${encodeURIComponent(target)}/exec`;
   const deadline = now() + timeoutMs;
 
+  // Sent on every attempt: a daemon that already started this run returns it
+  // instead of running the command again.
+  const runId = randomUUID();
+  let dedupes;
+  const retryable = async (error) => {
+    // The per-user in-flight cap (8) is full: nothing was started.
+    if (error?.status === 429) return true;
+    // A 502 is the daemon's own answer (bad workspace, …); a retry gets the same one.
+    if (!isRetryable(error) || error.status === 502 || now() >= deadline) return false;
+    // A network error or other 5xx may have started the command already.
+    dedupes ??= await dedupesRunId(config, basePath, fetchImpl, sleep);
+    return dedupes;
+  };
+
   const started = await withRetry(() => callApi(config, "POST", basePath, {
     command,
     args,
+    runId,
     ...(workspace ? { workspace } : {}),
     ...(env && Object.keys(env).length > 0 ? { env } : {}),
     // Deliberately short, and independent of the overall deadline: that is
     // owned by the poll loop below. Handing the daemon the full budget would
     // make one HTTP request block for it and leave the loop unreachable.
     timeoutMs: Math.min(timeoutMs, POST_WAIT_MS),
-  }, fetchImpl), { ...POST_RETRY, sleep });
+  }, fetchImpl), { attempts: POST_ATTEMPTS, retryable, sleep });
 
   const waited = await waitForRun(config, basePath, started, {
     deadline, fetchImpl, sleep, now, killOnTimeout, signal,
@@ -250,6 +265,21 @@ export async function execRemote(config, target, command, options = {}) {
   return { ...waited, basePath };
 }
 
+/**
+ * Whether the target dedupes exec on `runId`, which is what makes re-sending a
+ * POST that failed mid-flight safe. Asked only after such a failure, so the happy
+ * path pays nothing. Anything short of a clear yes — an old server answers 405,
+ * an old daemon `false` — keeps the POST to 429-only retries.
+ */
+async function dedupesRunId(config, basePath, fetchImpl, sleep) {
+  try {
+    const answer = await withRetry(() => callApi(config, "GET", basePath, null, fetchImpl), { sleep });
+    return answer?.dedupesRunId === true;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * `execRemote` for callers that only care whether it worked. Throws with the
  * remote's own stderr, which is what the user needs to see.

package/src/remote/mcp-launch.js

@@ -0,0 +1,167 @@
+/**
+ * Wiring `conductor remote mcp` into a remote-worktree task (RFC 0040).
+ *
+ * The daemon knows the task's `launch_config.remoteWorktree`; fire knows which
+ * AI backend it is about to start. The daemon resolves the binding (which
+ * daemon, which directory) and hands it to fire in one env var; fire turns it
+ * into that backend's MCP configuration. Kept free of heavy imports: both the
+ * daemon and fire load it on every task.
+ */
+
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+export const MCP_SERVER_NAME = "conductor_remote";
+export const REMOTE_WORKTREE_ENV = "CONDUCTOR_REMOTE_WORKTREE";
+
+/** The server's credentials travel by env, never argv (argv is world-readable in `ps`). */
+const FORWARDED_ENV = [
+  "CONDUCTOR_AGENT_TOKEN",
+  "CONDUCTOR_BACKEND_URL",
+  "CONDUCTOR_CONFIG",
+  "CONDUCTOR_HOME",
+  "CONDUCTOR_REMOTE_CHUNK_BYTES",
+  // Codex hands MCP servers only a minimal env; a corporate CA must still reach fetch.
+  "NODE_EXTRA_CA_CERTS",
+];
+
+/** remote_bash may wait up to 10 minutes; Codex's default MCP tool timeout is 60s. */
+const CODEX_TOOL_TIMEOUT_SEC = 900;
+
+const REMOTE_SCRIPT = fileURLToPath(new URL("../../bin/conductor-remote.js", import.meta.url));
+
+const str = (value) => (typeof value === "string" && value.trim() ? value.trim() : "");
+
+const isWindowsStylePath = (value) => /^[A-Za-z]:[\\/]/.test(value) || value.includes("\\");
+
+/**
+ * Where the remote worktree lives, from `launch_config.remoteWorktree`. Same
+ * math as web's `resolveRemoteWorktreePaths` and the daemon's
+ * `buildTaskWorktreeRoot`: `<workspacePath>/.conductor/worktrees/<branch>`, and
+ * the work dir is the project's offset inside the repository under that.
+ */
+export function resolveRemoteWorktreeBinding(launchConfig) {
+  const raw = launchConfig?.remoteWorktree ?? launchConfig?.remote_worktree;
+  if (!raw || typeof raw !== "object") return resolveRemoteWorkspaceBinding(launchConfig);
+  const host = str(raw.host);
+  const repoRoot = str(raw.repoRoot) || str(raw.repo_root);
+  const workspacePath = str(raw.workspacePath) || str(raw.workspace_path);
+  const branch = str(raw.branch);
+  if (!host || !repoRoot || !workspacePath || !branch) return null;
+
+  const pathApi = isWindowsStylePath(repoRoot) || isWindowsStylePath(workspacePath) ? path.win32 : path.posix;
+  const folder = branch.replace(/[/\\]/g, "_").replace(/\.\./g, "_");
+  const root = pathApi.join(workspacePath, ".conductor", "worktrees", folder);
+  const relative = pathApi.relative(repoRoot, workspacePath);
+  if (relative.startsWith("..") || pathApi.isAbsolute(relative)) return null;
+  const cwd = relative && relative !== "." ? pathApi.join(root, relative) : root;
+  return { host, root, cwd };
+}
+
+/**
+ * RFC 0041 direct mode: `launch_config.remoteWorkspace` points at the project
+ * directory itself (no worktree). The tools stay inside the repository and
+ * start in the project's directory.
+ */
+function resolveRemoteWorkspaceBinding(launchConfig) {
+  const raw = launchConfig?.remoteWorkspace ?? launchConfig?.remote_workspace;
+  if (!raw || typeof raw !== "object") return null;
+  const host = str(raw.host);
+  const repoRoot = str(raw.repoRoot) || str(raw.repo_root);
+  const workspacePath = str(raw.workspacePath) || str(raw.workspace_path);
+  if (!host || !repoRoot || !workspacePath) return null;
+  const pathApi = isWindowsStylePath(repoRoot) || isWindowsStylePath(workspacePath) ? path.win32 : path.posix;
+  const relative = pathApi.relative(repoRoot, workspacePath);
+  if (relative.startsWith("..") || pathApi.isAbsolute(relative)) return null;
+  return { host, root: repoRoot, cwd: workspacePath };
+}
+
+/** Env the daemon adds when it spawns fire. Empty for an ordinary task. */
+export function remoteWorktreeFireEnv(launchConfig) {
+  const binding = resolveRemoteWorktreeBinding(launchConfig);
+  return binding ? { [REMOTE_WORKTREE_ENV]: JSON.stringify(binding) } : {};
+}
+
+export function readRemoteWorktreeBinding(env = process.env) {
+  const raw = str(env?.[REMOTE_WORKTREE_ENV]);
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    const host = str(parsed?.host);
+    const root = str(parsed?.root);
+    const cwd = str(parsed?.cwd) || root;
+    return host && root ? { host, root, cwd } : null;
+  } catch {
+    return null;
+  }
+}
+
+function serverArgs(binding, configFile, remoteScript) {
+  return [
+    remoteScript,
+    "mcp",
+    "--host", binding.host,
+    "--root", binding.root,
+    "--cwd", binding.cwd,
+    // Absolute: the backend starts the server in the session's cwd, not ours.
+    ...(configFile ? ["--config-file", path.resolve(configFile)] : []),
+  ];
+}
+
+/**
+ * Session options that give the backend the remote workspace tools, merged
+ * over what the user configured. Only Claude and Codex are wired; any other
+ * backend gets nothing and keeps using `conductor remote exec` as before.
+ */
+export function buildRemoteWorktreeSessionOptions({
+  backend,
+  binding,
+  sessionOptions = {},
+  commandLine = "",
+  configFile = "",
+  env = process.env,
+  execPath = process.execPath,
+  remoteScript = REMOTE_SCRIPT,
+} = {}) {
+  if (!binding) return {};
+  const args = serverArgs(binding, configFile, remoteScript);
+  const normalizedBackend = String(backend || "").trim().toLowerCase();
+
+  if (normalizedBackend === "claude") {
+    const allowed = Array.isArray(sessionOptions.allowedTools) ? sessionOptions.allowedTools : [];
+    // Same precedence as the Claude session: explicit option, then the
+    // configured command line's `--permission-mode`.
+    const mode = sessionOptions.permissionMode
+      ?? String(commandLine || "").match(/--permission-mode[=\s]+([^\s"']+)/)?.[1];
+    return {
+      mcpServers: {
+        ...(sessionOptions.mcpServers || {}),
+        [MCP_SERVER_NAME]: { type: "stdio", command: execPath, args },
+      },
+      // Under the default bypassPermissions a root install is downgraded to
+      // acceptEdits, which would deny every remote_* call headless. A mode the
+      // user chose on purpose is left alone rather than widened.
+      ...(mode === undefined || mode === "bypassPermissions"
+        ? { allowedTools: [...new Set([...allowed, `mcp__${MCP_SERVER_NAME}`])] }
+        : {}),
+    };
+  }
+
+  if (normalizedBackend === "codex") {
+    // Values are TOML; JSON strings and string arrays are valid TOML as-is.
+    const prefix = `mcp_servers.${MCP_SERVER_NAME}`;
+    const forwarded = FORWARDED_ENV.filter((name) => str(env?.[name]));
+    return {
+      configOverrides: [
+        ...(Array.isArray(sessionOptions.configOverrides) ? sessionOptions.configOverrides : []),
+        `${prefix}.command=${JSON.stringify(execPath)}`,
+        `${prefix}.args=${JSON.stringify(args)}`,
+        ...(forwarded.length > 0 ? [`${prefix}.env_vars=${JSON.stringify(forwarded)}`] : []),
+        `${prefix}.tool_timeout_sec=${CODEX_TOOL_TIMEOUT_SEC}`,
+      ],
+    };
+  }
+
+  return {};
+}