@love-moon/conductor-cli 0.8.0 → 0.10.0

package/CHANGELOG.md

@@ -1,5 +1,49 @@
 # @love-moon/conductor-cli
 
+## 0.10.0
+
+### Minor Changes
+
+- 43c4f87: Runtime health preflight and agent schedule access control. The daemon now
+  advertises positive backend runtime health (`x-conductor-runtime-health`) so the
+  backend can reject task creation with `503 runtime_unavailable` before any
+  timeline activity, and adds `disable_built_in_cli_list` to opt out of built-in
+  SDK backends. The SDK attributes agent-originated scheduled-message calls with
+  `X-Conductor-Actor: agent` so per-task `agent_schedule_access`
+  (full/read_only/blocked) can govern `conductor task schedule` from agents while
+  human/UI calls stay unrestricted.
+
+### Patch Changes
+
+- 43c4f87: Fix `conductor fire` and `conductor diagnose` with an explicit `--config-file`
+  resolving `agent_token`/`backend_url` from daemon-injected `CONDUCTOR_*` env
+  instead of the file. Fire could dial the file's websocket with the inherited
+  token and loop on `4002 invalid-token`; diagnose queried the wrong backend and
+  404'd. An explicit config file now wins over inherited env, matching the
+  daemon's behavior.
+- 43c4f87: Fix `conductor update` installing into the wrong npm prefix.
+- Updated dependencies [43c4f87]
+- Updated dependencies [43c4f87]
+  - @love-moon/ai-sdk@0.10.0
+  - @love-moon/conductor-sdk@0.10.0
+
+## 0.9.0
+
+### Minor Changes
+
+- 3a499cc: Add `conductor remote-exec` for running a single command on another daemon's
+  host, over a new `remote_exec_request`/`remote_exec_response` daemon protocol
+  pair gated by a `remote_exec` capability. Supports `--workspace`, `--env`,
+  `--timeout` with automatic polling for long commands, `--kill-on-timeout`, and
+  ssh-style exit codes. Hosts can decline with `remote_exec: false` in the config.
+- a15b55d: Add per-turn multi-image and local context-file inputs, plus authenticated attachment materialization from Conductor Web to the executing daemon.
+
+### Patch Changes
+
+- Updated dependencies [a15b55d]
+  - @love-moon/ai-sdk@0.9.0
+  - @love-moon/conductor-sdk@0.9.0
+
 ## 0.8.0
 
 ### Minor Changes

package/bin/conductor-config.js

@@ -6,6 +6,7 @@ import path from "node:path";
 import process from "node:process";
 import readline from "node:readline/promises";
 import { execFileSync, execSync } from "node:child_process";
+import { createRequire } from "node:module";
 import yargs from "yargs/yargs";
 import { hideBin } from "yargs/helpers";
 import { RUNTIME_SUPPORTED_BACKENDS } from "../src/runtime-backends.js";
@@ -43,6 +44,11 @@ const DEFAULT_CLIs = {
     execArgs: "",
     description: "GitHub Copilot (built in via SDK)"
   },
+  dsh: {
+    command: "dsh",
+    execArgs: "",
+    description: "DeepSeek Harness agent (built in via SDK; needs DEEPSEEK_API_KEY)"
+  },
   // chat-web is the runtime backend (an in-process Chromium driver, not a CLI
   // binary). It has multiple sub-providers selected via --model. Each user-
   // facing alias below resolves to the chat-web runtime; advertising the bare
@@ -102,6 +108,20 @@ function isBuiltInChatWebAvailable() {
   );
 }
 
+function isBuiltInDshAvailable() {
+  // The dsh runtime ships as pinned dependencies of @love-moon/ai-sdk (not of
+  // the CLI itself), so resolve it THROUGH ai-sdk's resolution context — a
+  // direct resolve from cli/bin fails under pnpm's isolated node_modules.
+  try {
+    const require = createRequire(import.meta.url);
+    const aiSdkEntry = require.resolve("@love-moon/ai-sdk");
+    createRequire(aiSdkEntry).resolve("@deepseek-ai/dsh-sdk-jsonrpc-demo/bin");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 function buildConfigEntryLines(cli, info, { commented = false } = {}) {
   const fullCommand = info.execArgs
     ? `${info.command} ${info.execArgs}`
@@ -299,6 +319,16 @@ async function main() {
     });
   }
 
+  lines.push(
+    "",
+    "# Uncomment to disable built-in SDK backends that are otherwise advertised",
+    "# automatically (copilot, dsh). Listing a name here hides it from the",
+    "# daemon's supported backends without removing the shipped dependency.",
+    "# disable_built_in_cli_list:",
+    "#   - dsh",
+    "#   - copilot"
+  );
+
   lines.push(
     "",
     "# Uncomment to use custom envs, such as proxy.",
@@ -335,6 +365,10 @@ function detectInstalledCLIs() {
       detected.push(key);
       continue;
     }
+    if (runtimeBackend === "dsh" && isBuiltInDshAvailable()) {
+      detected.push(key);
+      continue;
+    }
     if (isCommandAvailable(info.command)) {
       detected.push(key);
     }

package/bin/conductor-diagnose.js

@@ -6,6 +6,8 @@ import { hideBin } from "yargs/helpers";
 
 import { loadConfig } from "@love-moon/conductor-sdk";
 
+import { envForExplicitConfigFile } from "../src/config-env.js";
+
 const CLI_NAME = process.env.CONDUCTOR_CLI_NAME || "conductor diagnose";
 const DEFAULT_TIMEOUT_MS = 8000;
 
@@ -45,7 +47,7 @@ main().catch((error) => {
 });
 
 async function main() {
-  const config = loadConfig(args.configFile);
+  const config = loadConfig(args.configFile, { env: envForExplicitConfigFile(args.configFile) });
   const timeoutMs = normalizePositiveInt(args.timeoutMs, DEFAULT_TIMEOUT_MS);
   const baseUrl = String(config.backendUrl || "").replace(/\/+$/, "");
   const endpoint = `${baseUrl}/api/diagnostics/tasks/${encodeURIComponent(taskId)}`;

package/bin/conductor-fire.js

@@ -583,6 +583,17 @@ export function createPendingRemoteInterruptQueue() {
 async function main() {
   syncPwdEnvWithProcessCwdForDaemonLaunch();
   const cliArgs = await parseCliArgs();
+  if (cliArgs.configFile) {
+    // An explicit --config-file must win over CONDUCTOR_* backend/token env
+    // injected by an owning daemon or session (same convention as
+    // envForExplicitConfigFile); otherwise fire dials the file's websocket
+    // with the inherited token and loops on 4002 invalid-token.
+    delete process.env.CONDUCTOR_AGENT_TOKEN;
+    delete process.env.CONDUCTOR_BACKEND_URL;
+    delete process.env.CONDUCTOR_WS_URL;
+    delete process.env.CONDUCTOR_BACKEND_WS_URL;
+    process.env.CONDUCTOR_CONFIG = cliArgs.configFile;
+  }
   let runtimeProjectPath = process.cwd();
   let backendSession = null;
 
@@ -798,7 +809,7 @@ async function main() {
       extraEnv: env,
       extraHeaders: buildConductorConnectHeaders(pkgJson.version, {
         backends: [cliArgs.backend],
-        capabilities: ["refresh_session_inplace"],
+        capabilities: ["refresh_session_inplace", "task_attachments_v1"],
       }),
       configFile: cliArgs.configFile,
       onConnected: (event) => {
@@ -3069,7 +3080,13 @@ export class BridgeRunner {
   }
 
   async respondToMessage(message) {
-    const content = String(message.content || "").trim();
+    const localAttachments = Array.isArray(message.attachments)
+      ? message.attachments.filter((attachment) =>
+          attachment && typeof attachment === "object" && typeof (attachment.path || attachment.localPath) === "string"
+        )
+      : [];
+    const rawContent = String(message.content || "").trim();
+    const content = rawContent || (localAttachments.length ? "Analyze the attached files." : "");
     if (!content) {
       this.copilotLog(`skip empty message replyTo=${message?.message_id || "latest"}`);
       return;
@@ -3091,6 +3108,22 @@ export class BridgeRunner {
       String(message.role || "").toLowerCase() === "user" &&
       content === this.pendingInitialPrompt;
     const useInitialImages = isQueuedInitialPromptMessage && this.includeInitialImages;
+    const nativeImageMimes = new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
+    const media = localAttachments
+      .filter((attachment) => attachment.kind === "image" && nativeImageMimes.has(String(attachment.mimeType || "").toLowerCase()))
+      .map((attachment) => ({
+        kind: "image",
+        path: attachment.path || attachment.localPath,
+        mimeType: attachment.mimeType,
+        name: attachment.name,
+      }));
+    const contextFiles = localAttachments
+      .filter((attachment) => !media.some((image) => image.path === (attachment.path || attachment.localPath)))
+      .map((attachment) => ({
+        path: attachment.path || attachment.localPath,
+        mimeType: attachment.mimeType,
+        name: attachment.name,
+      }));
     if (
       this.useSessionFileReplyStream &&
       typeof this.backendSession?.setSessionReplyTarget === "function"
@@ -3140,6 +3173,8 @@ export class BridgeRunner {
 
       const turnPromise = this.dispatchBackendTurn(content, {
         useInitialImages,
+        media,
+        contextFiles,
         onProgress: (payload) => {
           void this.reportRuntimeStatus(payload, replyTo);
         },
@@ -3330,8 +3365,12 @@ export class BridgeRunner {
     const goalCapable = Boolean(
       snapshot && snapshot.capabilities && snapshot.capabilities.goal === true,
     );
+    const hasAttachmentInputs =
+      (Array.isArray(options.media) && options.media.length > 0) ||
+      (Array.isArray(options.contextFiles) && options.contextFiles.length > 0);
     const willRunGoal =
       goalDirective != null &&
+      !hasAttachmentInputs &&
       goalCapable &&
       typeof this.backendSession?.runGoal === "function";
 

package/bin/conductor-remote-exec.js

@@ -0,0 +1,365 @@
+#!/usr/bin/env node
+
+/**
+ * conductor remote-exec — run one command on another daemon's host.
+ *
+ *   conductor remote-exec --target ubuntu --workspace /home/duino/ws/holomotion ls .
+ *   conductor remote-exec --target ubuntu -- bash -lc "pnpm build 2>&1 | tail -20"
+ *
+ * The command is sent as argv and spawned without a shell on the target, so
+ * quoting is not re-interpreted remotely. Pass `-- bash -lc "..."` when pipes
+ * or globs are actually wanted.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+import { ConductorConfig, loadConfig } from "@love-moon/conductor-sdk";
+import { envForExplicitConfigFile } from "../src/config-env.js";
+import { resolveConductorConfigPath } from "../src/conductor-paths.js";
+
+/**
+ * Following ssh: the remote command's exit code is passed through verbatim
+ * (0-254) and 255 is reserved for this CLI's own failures. Reusing 1/2/4 for
+ * local errors would make `grep` finding nothing (1) or `ls` on a missing path
+ * (2) indistinguishable from a network error or a usage mistake.
+ */
+const EXIT = { OK: 0, CLI_ERROR: 255 };
+const DEFAULT_TIMEOUT_MS = 60_000;
+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;
+
+const VALUE_FLAGS = new Map([
+  ["--target", "target"],
+  ["-t", "target"],
+  ["--workspace", "workspace"],
+  ["-w", "workspace"],
+  ["--timeout", "timeout"],
+  ["--config-file", "configFile"],
+  ["--env", "env"],
+  ["-e", "env"],
+]);
+
+const BOOL_FLAGS = new Map([
+  ["--json", "json"],
+  ["--kill-on-timeout", "killOnTimeout"],
+  ["--help", "help"],
+  ["-h", "help"],
+]);
+
+const isMainModule = (() => {
+  const currentFile = fileURLToPath(import.meta.url);
+  const entryFile = process.argv[1] ? path.resolve(process.argv[1]) : "";
+  return entryFile === currentFile;
+})();
+
+/**
+ * Split argv into flags and the remote command.
+ *
+ * Both `... --workspace /p ls .` and `... --workspace /p -- ls .` are accepted:
+ * the first token that is not a recognized flag starts the remote command, and
+ * everything after it is passed through verbatim.
+ */
+export function parseArgs(argv) {
+  const options = { env: {}, json: false, help: false };
+  const command = [];
+
+  let index = 0;
+  while (index < argv.length) {
+    const token = argv[index];
+
+    if (token === "--") {
+      command.push(...argv.slice(index + 1));
+      break;
+    }
+
+    let name = token;
+    let inlineValue = null;
+    if (token.startsWith("--") && token.includes("=")) {
+      const splitAt = token.indexOf("=");
+      name = token.slice(0, splitAt);
+      inlineValue = token.slice(splitAt + 1);
+    }
+
+    if (BOOL_FLAGS.has(name) && inlineValue === null) {
+      options[BOOL_FLAGS.get(name)] = true;
+      index += 1;
+      continue;
+    }
+
+    if (VALUE_FLAGS.has(name)) {
+      const key = VALUE_FLAGS.get(name);
+      const value = inlineValue !== null ? inlineValue : argv[index + 1];
+      if (value === undefined) {
+        throw new UsageError(`${name} requires a value`);
+      }
+      if (key === "env") {
+        const splitAt = value.indexOf("=");
+        if (splitAt <= 0) {
+          throw new UsageError(`--env expects KEY=VALUE, got: ${value}`);
+        }
+        options.env[value.slice(0, splitAt)] = value.slice(splitAt + 1);
+      } else {
+        options[key] = value;
+      }
+      index += inlineValue !== null ? 1 : 2;
+      continue;
+    }
+
+    command.push(...argv.slice(index));
+    break;
+  }
+
+  return { options, command };
+}
+
+export class UsageError extends Error {}
+
+/** Accepts `500ms`, `30s`, `2m`, or a bare number of seconds. */
+export function parseTimeoutMs(value) {
+  if (value === undefined || value === null || value === "") {
+    return DEFAULT_TIMEOUT_MS;
+  }
+  const raw = String(value).trim().toLowerCase();
+  const match = raw.match(/^(\d+(?:\.\d+)?)(ms|s|m)?$/);
+  if (!match) {
+    throw new UsageError(`invalid --timeout value: ${value}`);
+  }
+  const amount = Number.parseFloat(match[1]);
+  const unit = match[2] || "s";
+  const multiplier = unit === "ms" ? 1 : unit === "m" ? 60_000 : 1_000;
+  const ms = Math.round(amount * multiplier);
+  if (!Number.isFinite(ms) || ms <= 0) {
+    throw new UsageError(`invalid --timeout value: ${value}`);
+  }
+  return ms;
+}
+
+function loadCliConfig(configFile, env = process.env) {
+  const configPath = resolveConductorConfigPath(configFile, env);
+  const configEnv = envForExplicitConfigFile(configFile, env);
+  if (fs.existsSync(configPath)) {
+    return loadConfig(configPath, { env: configEnv });
+  }
+
+  const agentToken = typeof env.CONDUCTOR_AGENT_TOKEN === "string" ? env.CONDUCTOR_AGENT_TOKEN.trim() : "";
+  const backendUrl = typeof env.CONDUCTOR_BACKEND_URL === "string" ? env.CONDUCTOR_BACKEND_URL.trim() : "";
+  if (agentToken && backendUrl) {
+    return new ConductorConfig({ agentToken, backendUrl });
+  }
+
+  return loadConfig(configPath, { env: configEnv });
+}
+
+async function callApi(config, method, pathname, body, fetchImpl) {
+  const url = new URL(pathname, config.backendUrl);
+  const response = await fetchImpl(url.toString(), {
+    method,
+    headers: {
+      Authorization: `Bearer ${config.agentToken}`,
+      Accept: "application/json",
+      ...(body ? { "Content-Type": "application/json" } : {}),
+    },
+    ...(body ? { body: JSON.stringify(body) } : {}),
+  });
+
+  const text = await response.text();
+  let payload = null;
+  try {
+    payload = text ? JSON.parse(text) : null;
+  } catch {
+    payload = null;
+  }
+
+  if (!response.ok) {
+    const message = payload?.error || text.trim() || `HTTP ${response.status}`;
+    const error = new Error(message);
+    error.status = response.status;
+    throw error;
+  }
+  return payload;
+}
+
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+export function showHelp(consoleImpl = console) {
+  consoleImpl.log(`conductor remote-exec - run a command on another daemon's host
+
+Usage:
+  conductor remote-exec --target <daemon> [options] <command> [args...]
+  conductor remote-exec --target <daemon> [options] -- <command> [args...]
+
+Options:
+  -t, --target <daemon>   Daemon name to run on (required)
+  -w, --workspace <path>  Working directory on the target (default: target's home)
+      --timeout <dur>     Overall deadline, e.g. 30s, 2m, 500ms (default: 60s)
+  -e, --env KEY=VALUE     Extra environment variable (repeatable)
+      --json              Print the raw run result as JSON
+      --kill-on-timeout   Stop the remote command when --timeout is reached
+                          (default: it keeps running on the target)
+      --config-file <p>   Conductor config file to authenticate with
+  -h, --help              Show this help
+
+Notes:
+  The command is spawned without a shell. For pipes, globs or redirection use:
+    conductor remote-exec -t ubuntu -- bash -lc "ls | wc -l"
+
+  Exit codes follow ssh: the remote command's own code is passed through, and
+  255 means this CLI failed (bad usage, daemon offline, network error).
+
+Examples:
+  conductor remote-exec --target ubuntu --workspace /home/duino/ws/holomotion ls .
+  conductor remote-exec -t ubuntu -w /srv/app -- git log --oneline -5
+`);
+}
+
+export async function runRemoteExec(argv, deps = {}) {
+  const consoleImpl = deps.console || console;
+  const fetchImpl = deps.fetch || globalThis.fetch;
+  const env = deps.env || process.env;
+  const sleep = deps.sleep || delay;
+  const now = deps.now || (() => Date.now());
+
+  let parsed;
+  try {
+    parsed = parseArgs(argv);
+  } catch (error) {
+    consoleImpl.error(`Error: ${error.message}`);
+    return EXIT.CLI_ERROR;
+  }
+  const { options, command } = parsed;
+
+  if (options.help) {
+    showHelp(consoleImpl);
+    return EXIT.OK;
+  }
+
+  const target = typeof options.target === "string" ? options.target.trim() : "";
+  if (!target) {
+    consoleImpl.error("Error: --target <daemon> is required");
+    showHelp(consoleImpl);
+    return EXIT.CLI_ERROR;
+  }
+  if (command.length === 0) {
+    consoleImpl.error("Error: no command given");
+    showHelp(consoleImpl);
+    return EXIT.CLI_ERROR;
+  }
+
+  let timeoutMs;
+  try {
+    timeoutMs = parseTimeoutMs(options.timeout);
+  } catch (error) {
+    consoleImpl.error(`Error: ${error.message}`);
+    return EXIT.CLI_ERROR;
+  }
+
+  let config;
+  try {
+    config = deps.config || loadCliConfig(options.configFile, env);
+  } catch (error) {
+    consoleImpl.error(`Error: ${error.message}`);
+    return EXIT.CLI_ERROR;
+  }
+
+  const basePath = `/api/agents/${encodeURIComponent(target)}/exec`;
+  const deadline = now() + timeoutMs;
+
+  let run;
+  try {
+    run = await callApi(config, "POST", basePath, {
+      command: command[0],
+      args: command.slice(1),
+      ...(options.workspace ? { workspace: options.workspace } : {}),
+      ...(Object.keys(options.env).length > 0 ? { env: options.env } : {}),
+      // Deliberately short, and independent of `--timeout`: the overall deadline
+      // is owned by the poll loop below. Handing the daemon the full deadline
+      // would make one HTTP request block for it, and would leave the loop
+      // unreachable because the POST alone would consume the whole budget.
+      timeoutMs: Math.min(timeoutMs, POST_WAIT_MS),
+    }, fetchImpl);
+  } catch (error) {
+    consoleImpl.error(`Error: ${error.message}`);
+    return EXIT.CLI_ERROR;
+  }
+
+  let pollError = null;
+  while (run?.status === "running" && now() < deadline) {
+    if (!run.runId) {
+      pollError = new Error("daemon reported a running command but returned no runId");
+      break;
+    }
+    await sleep(POLL_INTERVAL_MS);
+    try {
+      run = await callApi(
+        config,
+        "GET",
+        `${basePath}/runs/${encodeURIComponent(run.runId)}`,
+        null,
+        fetchImpl,
+      );
+      pollError = null;
+    } catch (error) {
+      // A saturated or briefly unreachable daemon can fail one status poll.
+      // Keep waiting until the caller's own deadline rather than aborting a
+      // long-running command that is still perfectly healthy.
+      pollError = error;
+    }
+  }
+
+  if (run?.status === "running" && options.killOnTimeout && run.runId) {
+    try {
+      run = await callApi(
+        config,
+        "DELETE",
+        `${basePath}/runs/${encodeURIComponent(run.runId)}`,
+        null,
+        fetchImpl,
+      );
+      consoleImpl.error(`[conductor] deadline reached; stopped the command on ${target}`);
+    } catch (error) {
+      consoleImpl.error(`[conductor] failed to stop the run on ${target}: ${error.message}`);
+    }
+  }
+
+  if (options.json) {
+    consoleImpl.log(JSON.stringify(run, null, 2));
+  } else {
+    if (run?.stdoutTail) process.stdout.write(run.stdoutTail);
+    if (run?.stderrTail) process.stderr.write(run.stderrTail);
+    if (run?.truncated) {
+      consoleImpl.error(`[conductor] output truncated; showing the tail only`);
+    }
+    if (run?.error) {
+      consoleImpl.error(`Error: ${run.error}`);
+    }
+  }
+
+  if (run?.status === "running") {
+    if (pollError) {
+      consoleImpl.error(`[conductor] last status poll failed: ${pollError.message}`);
+    }
+    consoleImpl.error(
+      `[conductor] still running on ${target} after ${timeoutMs}ms; ` +
+        `it keeps going there — poll GET ${basePath}/runs/${run.runId}, ` +
+        `stop it with DELETE on the same path, or use --kill-on-timeout`,
+    );
+    return EXIT.CLI_ERROR;
+  }
+  if (run?.status === "cancelled") {
+    return EXIT.CLI_ERROR;
+  }
+  if (typeof run?.exitCode === "number") {
+    return run.exitCode;
+  }
+  return run?.status === "completed" ? EXIT.OK : EXIT.CLI_ERROR;
+}
+
+if (isMainModule) {
+  // `process.exitCode` rather than `process.exit()`: writes to a pipe are async,
+  // and exiting outright truncates them. Let the loop drain and end naturally.
+  process.exitCode = await runRemoteExec(process.argv.slice(2));
+}

package/bin/conductor-update.js

@@ -17,6 +17,7 @@ import {
   fetchLatestVersion,
   isNewerVersion,
   detectPackageManager,
+  resolveGlobalInstallPrefix,
 } from "../src/version-check.js";
 import {
   buildPnpmAllowBuildArgs,
@@ -163,6 +164,18 @@ async function performUpdate() {
   console.log(`   Using package manager: ${colorize(packageManager, "cyan")}`);
   console.log("");
 
+  // `npm install -g` targets whichever npm wins the PATH lookup, which is not necessarily the
+  // one that installed us -- a Conductor-managed Node, an nvm shim and a system npm all resolve
+  // to different prefixes. When they disagree the update lands in a tree nobody runs, so
+  // `conductor --version` keeps reporting the old build and the next update repeats the cycle.
+  // Pin every child command to the prefix the running package actually lives in.
+  const installPrefix = packageManager === "npm" ? resolveGlobalInstallPrefix(PKG_ROOT) : null;
+  if (installPrefix) {
+    process.env.npm_config_prefix = installPrefix;
+    console.log(`   Install prefix: ${colorize(installPrefix, "cyan")}`);
+    console.log("");
+  }
+
   if (packageManager === "pnpm") {
     console.log("   Preparing pnpm native dependency allowlist...");
     await ensurePnpmOnlyBuiltDependencies({

package/bin/conductor.js

@@ -15,6 +15,7 @@
  *   project  - Manage Conductor projects (list/show/create/...)
  *   issue    - Manage issues (list/show/create/update/start/done)
  *   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") {
@@ -135,6 +137,7 @@ Subcommands:
   project   Manage Conductor projects (list/show/create/...)
   issue     Manage issues (list/show/create/update/start/done)
   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
@@ -159,6 +162,7 @@ Examples:
   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
@@ -172,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.8.0",
-  "gitCommitId": "04d4f62",
+  "version": "0.10.0",
+  "gitCommitId": "bc7b3a5",
   "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.8.0",
-    "@love-moon/conductor-sdk": "0.8.0",
+    "@love-moon/ai-sdk": "0.10.0",
+    "@love-moon/conductor-sdk": "0.10.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.8.0"
+    "@love-moon/chat-web": "0.10.0"
   },
   "pnpm": {
     "onlyBuiltDependencies": [