@love-moon/conductor-cli 0.16.0 → 0.17.1

package/src/remote-file-handlers.js

@@ -38,6 +38,13 @@ const MAX_CONCURRENT_TRANSFERS = 4;
 const NUL = String.fromCharCode(0);
 
 export const REMOTE_FILE_CAPABILITY = "remote_file";
+/**
+ * This daemon enforces `rootPath` on `push` and resolves a relative path against
+ * a task's working directory. The backend must see it before opening a file
+ * preview: an older daemon would silently ignore `rootPath` and serve the whole
+ * disk to a preview link.
+ */
+export const REMOTE_FILE_PREVIEW_CAPABILITY = "remote_file_preview";
 
 /**
  * Move single files between this daemon's disk and the account that owns it,
@@ -68,6 +75,7 @@ export const REMOTE_FILE_CAPABILITY = "remote_file";
  * @param {number} [opts.chunkBytes]
  * @param {(ms:number)=>Promise<unknown>} [opts.sleep] backoff hook, injectable for tests
  * @param {string|null} [opts.guestRoot] when set, paths outside it are refused
+ * @param {(taskId:string)=>string|null} [opts.resolveTaskCwd] working directory of a live task
  */
 export function createRemoteFileHandlers(opts = {}) {
   const config = opts.config || null;
@@ -77,6 +85,7 @@ export function createRemoteFileHandlers(opts = {}) {
   const chunkBytes = resolveRemoteChunkBytes(opts.chunkBytes);
   const sleep = typeof opts.sleep === "function" ? opts.sleep : delay;
   const guestRoot = opts.guestRoot || null;
+  const resolveTaskCwd = typeof opts.resolveTaskCwd === "function" ? opts.resolveTaskCwd : () => null;
   // One controller for the whole daemon: `abortAll()` on shutdown tears down
   // every in-flight stream instead of letting them hold the process open.
   const shutdownController = new AbortController();
@@ -114,14 +123,57 @@ export function createRemoteFileHandlers(opts = {}) {
    * mistakes rather than a determined escape — same caveat as everywhere else
    * in this repo.
    */
-  function resolveRemotePath(value) {
-    const resolved = normalizeRemotePath(value);
+  function resolveRemotePath(value, taskId) {
+    const resolved = normalizeRemotePath(taskId ? resolveAgainstTask(value, taskId) : value);
     if (guestRoot && !isPathInsideGuestRoot(resolved, guestRoot)) {
       throw new Error(`path is outside this daemon's shared root: ${resolved}`);
     }
     return resolved;
   }
 
+  /** A link the AI wrote as `docs/report.md` means "relative to where I ran". */
+  function resolveAgainstTask(value, taskId) {
+    const raw = typeof value === "string" ? value.trim() : "";
+    if (!raw || path.isAbsolute(raw) || raw === "~" || raw.startsWith("~/")) return value;
+    const cwd = resolveTaskCwd(String(taskId));
+    if (!cwd) {
+      throw new Error(`cannot resolve relative path ${raw}: task ${taskId} is not running on this daemon`);
+    }
+    return path.join(cwd, raw);
+  }
+
+  /**
+   * Confine a preview read to `rootPath`. Unlike the guest-root check this one
+   * follows symlinks: the paths under a preview link are chosen by the page
+   * being previewed, not typed by the machine's owner, so a symlink into
+   * `~/.ssh` must not be a way out. Dotfiles below the root are refused for the
+   * same reason (`.env`, `.git/config`).
+   */
+  async function resolveInsideRoot(source, rootPath) {
+    let real;
+    let root;
+    try {
+      root = await fsp.realpath(normalizeRemotePath(rootPath));
+      real = await fsp.realpath(source);
+    } catch (error) {
+      if (error?.code === "ENOENT" || error?.code === "ENOTDIR") {
+        throw new Error(`no such file: ${source}`);
+      }
+      throw error;
+    }
+    const relative = path.relative(root, real);
+    if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
+      throw new Error(`path is outside the preview root: ${source}`);
+    }
+    if (relative.split(path.sep).some((segment) => segment.startsWith("."))) {
+      throw new Error(`hidden files are not available to preview: ${source}`);
+    }
+    if (guestRoot && !isPathInsideGuestRoot(real, await fsp.realpath(guestRoot))) {
+      throw new Error(`path is outside this daemon's shared root: ${source}`);
+    }
+    return real;
+  }
+
   async function acquireSlot() {
     if (activeTransfers >= MAX_CONCURRENT_TRANSFERS) {
       throw new Error(
@@ -306,7 +358,10 @@ export function createRemoteFileHandlers(opts = {}) {
   async function push(args = {}) {
     const transferId = requireId(args.transferId ?? args.transfer_id, "transferId");
     const transferToken = requireId(args.transferToken ?? args.transfer_token, "transferToken");
-    const source = resolveRemotePath(args.remotePath ?? args.remote_path);
+    let source = resolveRemotePath(args.remotePath ?? args.remote_path);
+    const rootPath = args.rootPath ?? args.root_path;
+    if (rootPath) source = await resolveInsideRoot(source, rootPath);
+    const limit = Math.min(maxBytes, toPositiveInt(args.maxBytes ?? args.max_bytes) || maxBytes);
 
     const stat = await statOrNull(source);
     if (!stat) {
@@ -318,8 +373,8 @@ export function createRemoteFileHandlers(opts = {}) {
     if (!stat.isFile()) {
       throw new Error(`${source} is not a regular file`);
     }
-    if (stat.size > maxBytes) {
-      throw new Error(`${source} is ${stat.size} bytes, over the ${maxBytes} byte limit`);
+    if (stat.size > limit) {
+      throw new Error(`${source} is ${stat.size} bytes, over the ${limit} byte limit`);
     }
 
     await acquireSlot();
@@ -414,11 +469,12 @@ export function createRemoteFileHandlers(opts = {}) {
 
   /** Probe a path. A missing path is an answer, not an error. */
   async function stat(args = {}) {
-    const target = resolveRemotePath(args.remotePath ?? args.remote_path);
+    const target = resolveRemotePath(args.remotePath ?? args.remote_path, args.taskId ?? args.task_id);
     const info = await statOrNull(target);
     if (!info) {
       return {
         path: target,
+        realPath: null,
         exists: false,
         isFile: false,
         isDirectory: false,
@@ -429,6 +485,9 @@ export function createRemoteFileHandlers(opts = {}) {
     }
     return {
       path: target,
+      // Symlinks resolved: a preview roots itself here, so that the root it
+      // later enforces is the directory the file really lives in.
+      realPath: await fsp.realpath(target),
       exists: true,
       isFile: info.isFile(),
       isDirectory: info.isDirectory(),

package/src/task-commands.js

@@ -102,10 +102,20 @@ export async function handleRestart(argv, deps) {
   if (trimmed(argv.backend)) body.backend_type = trimmed(argv.backend);
   if (argv.refreshSession) body.restart_mode = "refresh_session";
   if (trimmed(argv.daemonHost)) body.agent_host = trimmed(argv.daemonHost);
+  if (trimmed(argv.codeHost)) {
+    if (argv.strategy !== "new_task") throw argsError("--code-host requires --strategy new_task");
+    body.code_host = trimmed(argv.codeHost);
+  }
   if (trimmed(argv.firstMessage)) {
     if (argv.strategy !== "new_task") throw argsError("--first-message requires --strategy new_task");
     body.first_message = trimmed(argv.firstMessage);
   }
+  if (argv.newWorktree) {
+    if (argv.strategy !== "new_task") throw argsError("--new-worktree requires --strategy new_task");
+    // A fresh worktree does not load the source conversation; the first message replaces it.
+    if (!trimmed(argv.firstMessage)) throw argsError("--new-worktree requires --first-message");
+    body.new_worktree = true;
+  }
   if (argv.refreshSession && argv.strategy) {
     throw argsError("--refresh-session cannot be combined with --strategy");
   }
@@ -248,6 +258,15 @@ export async function handleShare(argv, deps) {
   return print(deps, argv, url ? { ...data, url } : data, url ? `Share link: ${url}` : `Shared task ${argv.id}`);
 }
 
+/** Open a temporary preview link for a file on the task's daemon (what clicking a file link in the chat does). */
+export async function handlePreview(argv, deps) {
+  const http = await buildHttp(deps);
+  const { dryRun, data } = await sendOrPreview(http, argv, deps, "POST", taskPath(argv.id, "preview"), { path: argv.path });
+  if (dryRun) return EXIT.OK;
+  const url = data?.viewUrl ? `${http.baseUrl}${data.viewUrl}` : null;
+  return print(deps, argv, url ? { ...data, url } : data, url ? `Preview link (expires after 5 idle minutes): ${url}` : `No preview link for ${argv.path}`);
+}
+
 export async function handleUnshare(argv, deps) {
   const http = await buildHttp(deps);
   const { dryRun, data } = await sendOrPreview(http, argv, deps, "DELETE", taskPath(argv.id, "share"));
@@ -317,6 +336,31 @@ export async function handleTranscribe(argv, deps) {
   return print(deps, argv, data, String(data?.text ?? ""));
 }
 
+/** Text to speech (the web voice mode's reply voice); saves an .mp3. */
+export async function handleSpeak(argv, deps) {
+  const text = trimmed(argv.text);
+  if (!text) throw argsError("Text is required");
+  const http = await buildHttp(deps);
+  if (argv.dryRun) {
+    return sendOrPreview(http, argv, deps, "POST", apiPath("speech", "synthesize"), { text, format: "mp3" }).then(() => EXIT.OK);
+  }
+  const response = await http.download(apiPath("speech", "synthesize"), { body: { text, format: "mp3" } });
+  let bytes;
+  try {
+    bytes = Buffer.from(await response.arrayBuffer());
+  } catch (error) {
+    // Synthesis failed mid-stream: never save a truncated file as success.
+    throw new Error(`Speech synthesis was interrupted: ${error?.message || String(error)}`);
+  }
+  if (argv.output === "-") {
+    deps.stdout.write(bytes);
+    return EXIT.OK;
+  }
+  const target = path.resolve(deps.cwd || process.cwd(), argv.output ? String(argv.output) : "speech.mp3");
+  fs.writeFileSync(target, bytes);
+  return print(deps, argv, { path: target, bytes: bytes.length }, `Saved ${bytes.length} bytes to ${target}`);
+}
+
 // ---- persistent tasks (RFC 0039) -----------------------------------------
 
 export async function handlePersistent(argv, deps) {
@@ -568,14 +612,21 @@ export function parseAgents(values) {
   });
 }
 
+/** `claude@l20`, as the web UI and `issue start` write it; the older `l20:claude` still parses. */
 export function parseGlobalBackend(value) {
   const raw = trimmed(value);
   if (!raw) return undefined;
-  const index = raw.indexOf(":");
-  const host = index > 0 ? raw.slice(0, index).trim() : "";
-  const backend = index > 0 ? raw.slice(index + 1).trim() : "";
-  if (!host || !backend) throw argsError("--global-backend must look like <host>:<backend>, e.g. l20:claude");
-  return { host, backend };
+  const at = raw.indexOf("@");
+  const colon = raw.indexOf(":");
+  const [backend, host] = at > 0
+    ? [raw.slice(0, at), raw.slice(at + 1)]
+    : colon > 0
+      ? [raw.slice(colon + 1), raw.slice(0, colon)]
+      : ["", ""];
+  if (!host.trim() || !backend.trim()) {
+    throw argsError("--global-backend must look like <backend>@<host>, e.g. claude@l20");
+  }
+  return { host: host.trim(), backend: backend.trim().toLowerCase() };
 }
 
 /** True when `task create` needs the full frontend payload rather than the SDK subset. */
@@ -585,24 +636,16 @@ export function hasExtendedCreateOptions(argv) {
       || (argv.agent && [].concat(argv.agent).length)
       || trimmed(argv.globalBackend)
       || argv.worktree
-      || trimmed(argv.remoteWorktree)
       || argv.persistent,
   );
 }
 
 export function buildExtendedCreateBody(argv, deps, projectId, title) {
-  if (argv.worktree && trimmed(argv.remoteWorktree)) {
-    throw argsError("Pass --worktree or --remote-worktree, not both");
-  }
   const globalBackend = parseGlobalBackend(argv.globalBackend);
   const agents = parseAgents(argv.agent);
   if (globalBackend && (agents.length || trimmed(argv.daemonHost))) {
     throw argsError("--global-backend cannot be combined with --agent or --daemon-host");
   }
-  // Both are rejected by POST /api/tasks; fail before the round trip.
-  if (globalBackend && trimmed(argv.remoteWorktree)) {
-    throw argsError("--global-backend cannot be combined with --remote-worktree");
-  }
   if (globalBackend && trimmed(argv.backend) && trimmed(argv.backend) !== globalBackend.backend) {
     throw argsError(
       `--backend ${trimmed(argv.backend)} does not match --global-backend backend ${globalBackend.backend}; drop --backend`,
@@ -625,8 +668,7 @@ export function buildExtendedCreateBody(argv, deps, projectId, title) {
     if (trimmed(argv.backend)) body.backendType = trimmed(argv.backend);
   }
   if (agents.length) body.agents = agents;
-  if (trimmed(argv.remoteWorktree)) body.launchConfig = { remoteWorktree: { host: trimmed(argv.remoteWorktree) } };
-  else if (argv.worktree) body.launchConfig = { worktree: true };
+  if (argv.worktree) body.launchConfig = { worktree: true };
   return body;
 }
 

package/src/version-check.js

@@ -162,6 +162,16 @@ export function resolveGlobalInstallPrefix(packageRoot) {
   return normalized.slice(0, markerIndex);
 }
 
+/**
+ * The directory of the running Node when it ships its own headers, which official tarballs, nvm
+ * and Homebrew all do. Handed to node-gyp as `npm_config_nodedir`, it compiles node-pty against
+ * those instead of downloading the headers from nodejs.org.
+ */
+export function resolveBundledNodeDir(nodeExecutable = process.execPath, { existsSync = fs.existsSync } = {}) {
+  const nodeDir = path.dirname(path.dirname(nodeExecutable));
+  return existsSync(path.join(nodeDir, "include", "node", "common.gypi")) ? nodeDir : null;
+}
+
 export function buildUpgradeCommand(options = {}) {
   const installMethod = resolveInstallMethod(options);
   if (installMethod === "homebrew") {