@love-moon/conductor-cli 0.11.1 → 0.12.0

package/src/daemon.js

@@ -42,6 +42,11 @@ import {
   createRemoteExecHandlers,
   handleRemoteExecRequest,
 } from "./remote-exec-handlers.js";
+import {
+  REMOTE_FILE_CAPABILITY,
+  createRemoteFileHandlers,
+  handleRemoteFileRequest,
+} from "./remote-file-handlers.js";
 import {
   UPDATE_DAEMON_CAPABILITY,
   createDaemonUpdateHandlers,
@@ -288,6 +293,33 @@ function getRemoteExecEnabled(userConfig) {
   return true;
 }
 
+// Whether this host will accept `conductor remote cp` file transfers (RFC
+// 0037). Kept separate from `remote_exec` on purpose: the two are not distinct
+// trust levels — anyone with exec can already `base64` a file — but a host may
+// well want scripted commands without letting the account push bytes onto its
+// disk, and a separate flag is the only way to say that.
+//
+// Resolution order:
+//   1. CONDUCTOR_REMOTE_FILE env var ("1"/"true"/"on" enable, "0"/"false"/"off" disable)
+//   2. remote_file boolean in the resolved Conductor config.yaml
+//   3. Default: true
+function getRemoteFileEnabled(userConfig) {
+  const rawEnv = process.env.CONDUCTOR_REMOTE_FILE;
+  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_file === false) {
+    return false;
+  }
+  return true;
+}
+
 function normalizePlanLimitType(limitType) {
   if (typeof limitType !== "string") {
     return null;
@@ -672,10 +704,102 @@ export function buildFireSpawnArgs({ selectedBackend, initialContent, launchConf
   if (effectivePrefill) {
     args.push("--prefill", effectivePrefill);
   }
+  const resumeSessionId =
+    normalizeOptionalString(launchConfig?.resumeSessionId) ||
+    normalizeOptionalString(launchConfig?.resume_session_id);
+  if (resumeSessionId) {
+    args.push("--resume", resumeSessionId);
+  }
   args.push("--");
   return args;
 }
 
+// Backends whose local session stores the ai-sdk resume module can enumerate.
+// Kept in sync with the server side of the `list_backend_sessions` RPC.
+const LISTABLE_SESSION_BACKENDS = ["claude", "codex", "kimi"];
+const DEFAULT_BACKEND_SESSION_LIMIT = 20;
+const MAX_BACKEND_SESSION_LIMIT = 50;
+
+// Lazy so a daemon running against an older ai-sdk build only fails when the
+// RPC is actually invoked (surfaced as a per-backend error), not at load time.
+async function listSessionsForBackendFromSdk(backendType, options) {
+  let sdk = await import("@love-moon/ai-sdk");
+  if (typeof sdk.listSessionsForBackend !== "function") {
+    // The root index can lag behind the resume module the function lives in;
+    // fall back to that entry point before declaring the sdk too old.
+    sdk = await import("@love-moon/ai-sdk/dist/resume/index.js").catch(() => sdk);
+  }
+  if (typeof sdk.listSessionsForBackend !== "function") {
+    throw new Error("Session listing is not supported by the installed ai-sdk");
+  }
+  return sdk.listSessionsForBackend(backendType, options);
+}
+
+/**
+ * Pure aggregation behind the `list_backend_sessions` RPC: intersect the
+ * requested backends with what this daemon supports, list each backend's
+ * sessions, and merge them newest-first. A single backend failing lands in
+ * `errors` without affecting the others. Exported so tests can drive it with
+ * a stubbed `listSessions`.
+ */
+export async function collectBackendSessions({
+  requestedBackends = null,
+  supportedBackends = [],
+  limit,
+  listSessions = listSessionsForBackendFromSdk,
+} = {}) {
+  const numericLimit = Number(limit);
+  const effectiveLimit =
+    Number.isFinite(numericLimit) && numericLimit > 0
+      ? Math.min(Math.floor(numericLimit), MAX_BACKEND_SESSION_LIMIT)
+      : DEFAULT_BACKEND_SESSION_LIMIT;
+  const listableBackends = LISTABLE_SESSION_BACKENDS.filter((backend) => supportedBackends.includes(backend));
+  const errors = [];
+  let backends;
+  if (Array.isArray(requestedBackends)) {
+    backends = [];
+    for (const raw of requestedBackends) {
+      const backend = typeof raw === "string" ? raw.trim().toLowerCase() : "";
+      if (!backend || backends.includes(backend)) {
+        continue;
+      }
+      if (!listableBackends.includes(backend)) {
+        errors.push({ backend, message: `Backend "${backend}" does not support session listing on this daemon` });
+        continue;
+      }
+      backends.push(backend);
+    }
+  } else {
+    backends = listableBackends;
+  }
+  const sessions = [];
+  for (const backend of backends) {
+    try {
+      const listed = await listSessions(backend, { limit: effectiveLimit });
+      for (const entry of Array.isArray(listed) ? listed : []) {
+        const sessionId = normalizeOptionalString(entry?.sessionId);
+        if (!sessionId) {
+          continue;
+        }
+        sessions.push({
+          backend,
+          session_id: sessionId,
+          session_file_path: normalizeOptionalString(entry?.sessionFilePath),
+          cwd: normalizeOptionalString(entry?.cwd),
+          title: normalizeOptionalString(entry?.title),
+          updated_at: Number.isFinite(entry?.updatedAt) ? new Date(entry.updatedAt).toISOString() : null,
+        });
+      }
+    } catch (error) {
+      errors.push({ backend, message: error?.message || String(error) });
+    }
+  }
+  // ISO 8601 strings compare lexicographically; entries without a timestamp
+  // sort last.
+  sessions.sort((a, b) => (b.updated_at || "").localeCompare(a.updated_at || ""));
+  return { sessions, errors };
+}
+
 function normalizeBooleanFlag(value) {
   if (typeof value === "boolean") {
     return value;
@@ -1062,6 +1186,10 @@ export function startDaemon(config = {}, deps = {}) {
   // path would cost function without removing reach (RFC 0034 makes the same
   // argument). An owner who wants it off can set `remote_exec: false`.
   const remoteExecEnabled = getRemoteExecEnabled(userConfig);
+  // Same reasoning for file transfer, with one addition: when the share scoped
+  // the guest to a root, transfers are confined to it (`isPathInsideGuestRoot`,
+  // a lexical check — misuse prevention, not a security boundary).
+  const remoteFileEnabled = getRemoteFileEnabled(userConfig);
 
   // Get allow_cli_list from config
   const RAW_ALLOW_CLI_LIST = getRawAllowCliList(userConfig);
@@ -3663,6 +3791,7 @@ export function startDaemon(config = {}, deps = {}) {
     "restart_daemon",
     "refresh_session_inplace",
     "task_attachments_v1",
+    "backend_session_list",
     CUSTOM_COMMANDS_CAPABILITY,
     UPDATE_DAEMON_CAPABILITY,
   ];
@@ -3671,6 +3800,11 @@ export function startDaemon(config = {}, deps = {}) {
   } else {
     log("[remote-exec] Disabled by config (remote_exec: false); capability not advertised");
   }
+  if (remoteFileEnabled) {
+    advertisedCapabilities.push(REMOTE_FILE_CAPABILITY);
+  } else {
+    log("[remote-file] Disabled by config (remote_file: false); capability not advertised");
+  }
   if (ptyTaskCapabilityEnabled) {
     advertisedCapabilities.push("pty_task", "terminal_snapshot");
   }
@@ -3738,6 +3872,13 @@ export function startDaemon(config = {}, deps = {}) {
   const remoteExecHandlers = remoteExecEnabled
     ? createRemoteExecHandlers({ defaultWorkspace: homeDir })
     : null;
+  const remoteFileHandlers = remoteFileEnabled
+    ? createRemoteFileHandlers({
+        config: sdkConfig,
+        agentHost: AGENT_NAME,
+        guestRoot: IS_GUEST_DAEMON ? GUEST_ROOT : null,
+      })
+    : null;
 
   const client = createWebSocketClient(sdkConfig, {
     extraHeaders,
@@ -6173,6 +6314,10 @@ export function startDaemon(config = {}, deps = {}) {
       void handleGetProjectAgents(event.payload);
       return;
     }
+    if (event.type === "list_backend_sessions") {
+      void handleListBackendSessions(event.payload);
+      return;
+    }
     if (event.type === "ai_manager_request") {
       // RFC 0035: reads are fine and genuinely useful to a guest (it needs to
       // know how much quota the borrowed machine has left). `switch_account` is
@@ -6237,6 +6382,50 @@ export function startDaemon(config = {}, deps = {}) {
         logError(`Unhandled remote_exec_request failure: ${error?.message || error}`);
       });
     }
+    if (event.type === "remote_file_request") {
+      // Same reason as remote exec: a transfer leaves no Task row and no
+      // per-run log, so it would be invisible after a restart. Only the action,
+      // the path and the byte count are recorded — never file contents, and
+      // never the transfer token, because this log is collected by
+      // `collect_logs`.
+      const fileArgs = event?.payload?.args && typeof event.payload.args === "object" ? event.payload.args : {};
+      log(
+        `[remote-file] ${event?.payload?.action || "?"} path=${fileArgs.remotePath || fileArgs.remote_path || ""} ` +
+          `bytes=${fileArgs.sizeBytes ?? fileArgs.size_bytes ?? "?"}`,
+      );
+      // 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 = !remoteFileHandlers
+        ? "remote file transfer is disabled on this daemon (remote_file: false)"
+        : daemonShuttingDown
+          ? "daemon is shutting down"
+          : "";
+      if (rejectReason) {
+        void client
+          .sendJson({
+            type: "remote_file_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;
+      }
+      handleRemoteFileRequest(client, remoteFileHandlers, event.payload)
+        .then((response) => {
+          if (response?.result) {
+            log(
+              `[remote-file] ${event?.payload?.action || "?"} ok path=${response.result.path || ""} ` +
+                `bytes=${response.result.bytesWritten ?? response.result.sizeBytes ?? "?"}`,
+            );
+          }
+        })
+        .catch((error) => {
+          logError(`Unhandled remote_file_request failure: ${error?.message || error}`);
+        });
+    }
     if (event.type === "restart_daemon") {
       void handleRestartDaemon(event.payload).catch((error) => {
         logError(`Unhandled restart_daemon failure: ${error?.message || error}`);
@@ -6551,6 +6740,42 @@ export function startDaemon(config = {}, deps = {}) {
     }
   }
 
+  async function handleListBackendSessions(payload) {
+    const requestId = payload?.request_id ? String(payload.request_id).trim() : "";
+    if (!requestId) {
+      logError(`Invalid list_backend_sessions payload: ${JSON.stringify(payload)}`);
+      return;
+    }
+
+    let result;
+    try {
+      result = await collectBackendSessions({
+        requestedBackends: Array.isArray(payload?.backends) ? payload.backends : null,
+        supportedBackends: SUPPORTED_BACKENDS,
+        limit: payload?.limit,
+        listSessions: deps.listBackendSessions,
+      });
+    } catch (error) {
+      result = {
+        sessions: [],
+        errors: [{ backend: "*", message: `Failed to list backend sessions on daemon ${AGENT_NAME}: ${error?.message || error}` }],
+      };
+    }
+
+    try {
+      await client.sendJson({
+        type: "backend_sessions_listed",
+        payload: {
+          request_id: requestId,
+          sessions: result.sessions,
+          errors: result.errors,
+        },
+      });
+    } catch (error) {
+      logError(`Failed to report backend_sessions_listed for ${requestId}: ${error?.message || error}`);
+    }
+  }
+
   function stopActiveTaskProcess(
     taskId,
     {
@@ -7125,6 +7350,49 @@ export function startDaemon(config = {}, deps = {}) {
       });
   }
 
+  /**
+   * Recover the workspace of a resumable session from the backend's own
+   * session store. Used when neither a launch-config cwd nor a bound project
+   * path is available -- the Default Project resuming a local session -- so the
+   * task runs (and logs) where the conversation actually lives instead of an
+   * unrelated scratch directory.
+   *
+   * Returns "" when the session cannot be located; callers keep their own
+   * fallbacks. `runtimeBackend` short-circuits the alias lookup for callers
+   * that already resolved it.
+   */
+  async function resolveSessionResumeCwd({ backendType, runtimeBackend = "", sessionId }) {
+    const normalizedSessionId = typeof sessionId === "string" ? sessionId.trim() : "";
+    const normalizedBackend = normalizeRuntimeBackendName(backendType);
+    // opencode has no resumable local session store to look the cwd up in.
+    if (!normalizedSessionId || !normalizedBackend || normalizedBackend === "opencode") {
+      return "";
+    }
+    try {
+      let resumeBackend = normalizeOptionalString(runtimeBackend);
+      if (!resumeBackend) {
+        const configuredBackend = await resolveConfiguredRuntimeBackend(normalizedBackend, ALLOW_CLI_LIST, {
+          configFilePath: config.CONFIG_FILE,
+        });
+        resumeBackend = configuredBackend?.runtimeBackend ||
+          await normalizeRuntimeBackendAlias(normalizedBackend, { configFilePath: config.CONFIG_FILE });
+      }
+      const resumeContext = await (deps.resolveResumeContext || resolveResumeContext)(
+        resumeBackend,
+        normalizedSessionId,
+        {
+          cwd: process.cwd(),
+          configFilePath: config.CONFIG_FILE,
+        },
+      );
+      return normalizeOptionalString(resumeContext?.cwd) || "";
+    } catch {
+      // Provider lookup failed (unknown id, unreadable store): let the caller
+      // fall back rather than failing the task here.
+      return "";
+    }
+  }
+
   async function resolveRestartCwd({
     taskId,
     projectId,
@@ -7158,29 +7426,9 @@ export function startDaemon(config = {}, deps = {}) {
       return boundPath;
     }
 
-    const normalizedBackend = normalizeRuntimeBackendName(backendType);
-    const normalizedSessionId = typeof sessionId === "string" ? sessionId.trim() : "";
-    if (normalizedSessionId && normalizedBackend && normalizedBackend !== "opencode") {
-      try {
-        const configuredBackend = await resolveConfiguredRuntimeBackend(normalizedBackend, ALLOW_CLI_LIST, {
-          configFilePath: config.CONFIG_FILE,
-        });
-        const resumeBackend = configuredBackend?.runtimeBackend ||
-          await normalizeRuntimeBackendAlias(normalizedBackend, { configFilePath: config.CONFIG_FILE });
-        const resumeContext = await (deps.resolveResumeContext || resolveResumeContext)(
-          resumeBackend,
-          normalizedSessionId,
-          {
-            cwd: process.cwd(),
-            configFilePath: config.CONFIG_FILE,
-          },
-        );
-        if (typeof resumeContext?.cwd === "string" && resumeContext.cwd.trim()) {
-          return resumeContext.cwd.trim();
-        }
-      } catch {
-        // ignore provider-specific fallback failure here; we'll try the remaining fallbacks
-      }
+    const sessionCwd = await resolveSessionResumeCwd({ backendType, sessionId });
+    if (sessionCwd) {
+      return sessionCwd;
     }
 
     const normalizedSessionPath =
@@ -7341,7 +7589,14 @@ export function startDaemon(config = {}, deps = {}) {
           launchConfig,
         })) ||
         normalizeOptionalString(launchConfig.cwd) ||
-        boundPath;
+        boundPath ||
+        (await resolveSessionResumeCwd({
+          backendType: requestedBackend,
+          runtimeBackend: effectiveBackend,
+          sessionId:
+            normalizeOptionalString(launchConfig?.resumeSessionId) ||
+            normalizeOptionalString(launchConfig?.resume_session_id),
+        }));
 
       if (resolvedTaskWorkspace) {
         taskDir = resolvedTaskWorkspace;
@@ -7940,6 +8195,31 @@ export function startDaemon(config = {}, deps = {}) {
       return;
     }
 
+    if (!resolvedResumeCwd && isForkMode) {
+      // A fork starts a brand-new session and receives its context as a URL, so
+      // it does not need the source task's files. When nothing in the chain
+      // resolves — the normal case for a cross-daemon fork, where the server
+      // drops the source machine's paths and this daemon holds no local path
+      // for the project — land in a fresh workspace dir exactly like
+      // create_task does, instead of killing the successor on arrival.
+      const now = new Date();
+      // Keyed off the task id, not the daemon pid: the run timestamp only has
+      // second granularity and this path never renames the dir afterwards
+      // (create_task does), so two forks landing in the same second would
+      // otherwise share one workspace AND one conductor.log.
+      const taskSuffix =
+        normalizedTargetTaskId.replace(/[^a-zA-Z0-9]/g, "").slice(0, 8) || String(process.pid);
+      resolvedResumeCwd = path.join(
+        WORKSPACE_ROOT,
+        formatWorkspaceDate(now),
+        `${formatWorkspaceRunTimestamp(now)}_fork_${taskSuffix}`,
+      );
+      log(
+        `No local workspace for project ${normalizedProjectId} on this daemon; ` +
+          `forking task ${normalizedTargetTaskId} into ${resolvedResumeCwd}`,
+      );
+    }
+
     if (!resolvedResumeCwd) {
       reportRestartFailure({
         taskId: normalizedTargetTaskId,
@@ -8409,6 +8689,9 @@ export function startDaemon(config = {}, deps = {}) {
         clearInterval(tmuxLivenessTimer);
         tmuxLivenessTimer = null;
       }
+      // An in-flight transfer holds an open socket and a `.part` file; abort
+      // them so shutdown is not gated on a multi-gigabyte download finishing.
+      remoteFileHandlers?.abortAll();
       const activeProcessEntries = [...activeTaskProcesses.entries()];
       const activePtyEntries = [...activePtySessions.entries()];
       const activeEntries = [...activeProcessEntries, ...activePtyEntries];

package/src/remote/archive.js

@@ -0,0 +1,129 @@
+/**
+ * Directory transfer, built on the single-file path plus `tar`.
+ *
+ * `remote cp -r` packs a directory locally (or remotely), moves the one
+ * resulting tarball through the ordinary transfer, then unpacks it on the other
+ * side. No new protocol: the wire still only ever carries one file.
+ *
+ * The remote halves run through `sh -c` with the paths passed as **positional
+ * arguments**, never interpolated into the script text. A directory literally
+ * named `; rm -rf /` is therefore just an awkward directory name.
+ */
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+
+/** Where the target stages its tarball. Overridable for hosts without /tmp. */
+export function remoteTempPath(env = process.env) {
+  const root = (env.CONDUCTOR_REMOTE_TMP || "/tmp").replace(/\/+$/, "") || "/tmp";
+  return `${root}/.conductor-rcp-${randomUUID()}.tgz`;
+}
+
+export function localTempPath() {
+  return path.join(os.tmpdir(), `.conductor-rcp-${randomUUID()}.tgz`);
+}
+
+/**
+ * Unpack `$1` into `$2`, following scp: an existing destination directory
+ * receives the source *inside* it; a missing one becomes the copy itself.
+ * `$3` is the source's basename, which is the top-level entry in the tarball.
+ */
+export const EXTRACT_SCRIPT = `
+set -e
+tmp=$1; dest=$2; base=$3
+if [ -d "$dest" ]; then
+  tar xzf "$tmp" -C "$dest"
+else
+  parent=$(dirname "$dest")
+  mkdir -p "$parent"
+  # Unpack into a private staging dir, never straight into the parent: the
+  # tarball's top entry is the SOURCE's name, and an unrelated neighbour of
+  # the destination could already have it. Extracting in place would clobber
+  # that neighbour, and the rename below would then carry it off.
+  # Staging inside the parent keeps the final mv on one filesystem.
+  stage=$(mktemp -d "$parent/.conductor-rcp-XXXXXX")
+  tar xzf "$tmp" -C "$stage"
+  rm -rf "$dest"
+  mv "$stage/$base" "$dest"
+  rmdir "$stage"
+fi
+`.trim();
+
+/** Pack directory `$1` into tarball `$2`, keeping `$1`'s own name inside. */
+export const PACK_SCRIPT = `
+set -e
+src=$1; tmp=$2
+if [ ! -d "$src" ]; then
+  echo "not a directory: $src" >&2
+  exit 1
+fi
+tar czf "$tmp" -C "$(dirname "$src")" "$(basename "$src")"
+`.trim();
+
+/** Remove the staged tarball. Never fails the transfer. */
+export const CLEANUP_SCRIPT = 'rm -f "$1"';
+
+/** `sh -c <script> sh <args...>` — the `sh` placeholder becomes $0. */
+export function shellArgs(script, ...args) {
+  return ["-c", script, "sh", ...args];
+}
+
+function runLocal(command, args, { spawnFn = spawn } = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawnFn(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stderr = "";
+    child.stderr?.on("data", (chunk) => {
+      // Bounded: a pathological tar could otherwise stream forever.
+      if (stderr.length < 8192) stderr += String(chunk);
+    });
+    child.on("error", (error) =>
+      reject(new Error(`failed to run ${command}: ${error.message}`)));
+    child.on("close", (code) => {
+      if (code === 0) return resolve();
+      reject(new Error(`${command} exited ${code}${stderr.trim() ? `: ${stderr.trim()}` : ""}`));
+    });
+  });
+}
+
+/** Pack a local directory, preserving its own name as the top-level entry. */
+export async function packLocalDirectory(sourceDir, tarball, deps = {}) {
+  await runLocal(
+    "tar",
+    ["czf", tarball, "-C", path.dirname(sourceDir), path.basename(sourceDir)],
+    deps,
+  );
+  return tarball;
+}
+
+/** Unpack locally with the same scp semantics as `EXTRACT_SCRIPT`. */
+export async function unpackLocalDirectory(tarball, destination, baseName, deps = {}) {
+  const fsp = deps.fsp || fs.promises;
+  let destStat = null;
+  try {
+    destStat = await fsp.stat(destination);
+  } catch {
+    destStat = null;
+  }
+
+  if (destStat?.isDirectory()) {
+    await runLocal("tar", ["xzf", tarball, "-C", destination], deps);
+    return path.join(destination, baseName);
+  }
+
+  const parent = path.dirname(destination);
+  await fsp.mkdir(parent, { recursive: true });
+  // Same reasoning as EXTRACT_SCRIPT: stage in a private directory so an
+  // existing neighbour that happens to share the source's name survives.
+  const stage = await fsp.mkdtemp(path.join(parent, ".conductor-rcp-"));
+  try {
+    await runLocal("tar", ["xzf", tarball, "-C", stage], deps);
+    await fsp.rm(destination, { recursive: true, force: true });
+    await fsp.rename(path.join(stage, baseName), destination);
+  } finally {
+    await fsp.rm(stage, { recursive: true, force: true }).catch(() => {});
+  }
+  return destination;
+}