@love-moon/conductor-cli 0.1.1 → 0.1.3

package/bin/conductor-config.js

@@ -12,12 +12,10 @@ const CONFIG_FILE = path.join(CONFIG_DIR, "config.yaml");
 const backendUrl =
   process.env.CONDUCTOR_BACKEND_URL ||
   process.env.BACKEND_URL ||
-  "http://localhost:6152";
+  "https://conductor-ai.top";
 
 const websocketUrl =
-  process.env.CONDUCTOR_WS_URL ||
-  process.env.PUBLIC_WS_URL ||
-  deriveWebsocketUrl(backendUrl);
+  process.env.CONDUCTOR_WS_URL || process.env.PUBLIC_WS_URL || "";
 
 async function main() {
   if (fs.existsSync(CONFIG_FILE)) {
@@ -40,7 +38,11 @@ async function main() {
   if (websocketUrl) {
     lines.push(`websocket_url: ${yamlQuote(websocketUrl)}`);
   }
-  lines.push("log_level: info", "");
+  lines.push("log_level: debug", "");
+  lines.push("allow_cli_list:", "");
+  lines.push("codex: codex exec --dangerously-bypass-approvals-and-sandbox --skip-git-repo-check", "");
+  lines.push("claude: claude --dangerously-skip-permissions", "");
+  lines.push("copilot: copilot --allow-all-paths --allow-all-tools -i", "");
 
   fs.writeFileSync(CONFIG_FILE, lines.join("\n"), "utf-8");
   process.stdout.write(`Wrote Conductor config to ${CONFIG_FILE}\n`);
@@ -62,16 +64,6 @@ async function promptForToken() {
   }
 }
 
-function deriveWebsocketUrl(url) {
-  try {
-    const parsed = new URL(url);
-    const scheme = parsed.protocol === "https:" ? "wss" : "ws";
-    return `${scheme}://${parsed.host}/ws/agent`;
-  } catch {
-    return "";
-  }
-}
-
 function yamlQuote(value) {
   return JSON.stringify(value);
 }

package/bin/conductor-daemon.js

@@ -11,8 +11,10 @@ import { startDaemon } from "../src/daemon.js";
 
 const argv = hideBin(process.argv);
 
+const CLI_NAME = process.env.CONDUCTOR_CLI_NAME || "conductor-daemon";
+
 const args = yargs(argv)
-  .scriptName("conductor-daemon")
+  .scriptName(CLI_NAME)
   .usage("Usage: $0 [--name <daemon-name>] [--clean-all] [--config-file <path>] [--nohup]")
   .option("name", {
     alias: "n",
@@ -56,7 +58,7 @@ if (args.nohup) {
     env: { ...process.env },
   });
   child.unref();
-  process.stdout.write(`conductor-daemon running in background. Logs: ${logPath}\n`);
+  process.stdout.write(`${CLI_NAME} running in background. Logs: ${logPath}\n`);
   process.exit(0);
 }
 

package/bin/conductor-fire.js

@@ -3,12 +3,13 @@
 /**
  * conductor-fire - Conductor-aware AI coding agent runner.
  *
- * Supports multiple backends: codex, claude, copilot, tmates, cursor, gemini.
+ * Supports configurable backends via allow_cli_list in config file.
  * This CLI bridges various AI coding agents with Conductor via MCP.
  */
 
 import fs from "node:fs";
 import { createRequire } from "node:module";
+import os from "node:os";
 import path from "node:path";
 import process from "node:process";
 import { setTimeout as delay } from "node:timers/promises";
@@ -18,6 +19,7 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import yargs from "yargs/yargs";
 import { hideBin } from "yargs/helpers";
+import yaml from "js-yaml";
 import { cli2sdk } from "@love-moon/cli2sdk";
 import { loadConfig } from "@love-moon/conductor-sdk";
 import {
@@ -51,9 +53,69 @@ const CLI_NAME = (process.env.CONDUCTOR_CLI_NAME || path.basename(process.argv[1
   "",
 );
 
-// Supported backends
-const SUPPORTED_BACKENDS = ["codex", "claude", "copilot", "tmates", "cursor", "gemini"];
-const DEFAULT_BACKEND = process.env.CONDUCTOR_BACKEND || "codex";
+// Load allow_cli_list from config file (no defaults - must be configured)
+function loadAllowCliList(configFilePath) {
+  try {
+    const home = os.homedir();
+    const configPath = configFilePath || process.env.CONDUCTOR_CONFIG || path.join(home, ".conductor", "config.yaml");
+    if (fs.existsSync(configPath)) {
+      const content = fs.readFileSync(configPath, "utf8");
+      const parsed = yaml.load(content);
+      if (parsed && typeof parsed === "object" && parsed.allow_cli_list) {
+        return parsed.allow_cli_list;
+      }
+    }
+  } catch (error) {
+    // ignore error
+  }
+  return {};
+}
+
+// Load envs config from config file
+function loadEnvConfig(configFilePath) {
+  try {
+    const home = os.homedir();
+    const configPath = configFilePath || process.env.CONDUCTOR_CONFIG || path.join(home, ".conductor", "config.yaml");
+    if (fs.existsSync(configPath)) {
+      const content = fs.readFileSync(configPath, "utf8");
+      const parsed = yaml.load(content);
+      if (parsed && typeof parsed === "object" && parsed.envs) {
+        return parsed.envs;
+      }
+    }
+  } catch (error) {
+    // ignore error
+  }
+  return null;
+}
+
+// Convert proxy env values to standard proxy environment variables
+function proxyToEnv(envConfig) {
+  if (!envConfig || typeof envConfig !== "object") {
+    return {};
+  }
+  const env = {};
+  // Support both snake_case and lowercase keys
+  const mappings = {
+    http_proxy: ["HTTP_PROXY", "http_proxy"],
+    https_proxy: ["HTTPS_PROXY", "https_proxy"],
+    all_proxy: ["ALL_PROXY", "all_proxy"],
+    no_proxy: ["NO_PROXY", "no_proxy"],
+  };
+  for (const [key, envKeys] of Object.entries(mappings)) {
+    const value = envConfig[key] || envConfig[key.toUpperCase()];
+    if (value) {
+      for (const envKey of envKeys) {
+        env[envKey] = value;
+      }
+    }
+  }
+  return env;
+}
+
+// Get CLI command from environment variable (set by daemon) or from config
+const CUSTOM_CLI_COMMAND = process.env.CONDUCTOR_CLI_COMMAND;
+const DEFAULT_ALLOW_CLI_LIST = loadAllowCliList();
 
 const DEFAULT_POLL_INTERVAL_MS = parseInt(
   process.env.CONDUCTOR_CLI_POLL_INTERVAL_MS || process.env.CCODEX_POLL_INTERVAL_MS || "2000",
@@ -78,9 +140,19 @@ async function main() {
     return;
   }
 
+  const allowCliList = loadAllowCliList(cliArgs.configFile);
+  const supportedBackends = Object.keys(allowCliList);
+
   if (cliArgs.listBackends) {
-    process.stdout.write(`Supported backends: ${SUPPORTED_BACKENDS.join(", ")}\n`);
-    process.stdout.write(`Default: ${DEFAULT_BACKEND}\n`);
+    if (supportedBackends.length === 0) {
+      process.stdout.write(`No backends configured.\n\nAdd allow_cli_list to your config file (~/.conductor/config.yaml):\n  allow_cli_list:\n    codex: codex --dangerously-bypass-approvals-and-sandbox\n    claude: claude --dangerously-skip-permissions\n`);
+    } else {
+      process.stdout.write(`Supported backends (from config):\n`);
+      for (const [name, command] of Object.entries(allowCliList)) {
+        process.stdout.write(`  ${name}: ${command}\n`);
+      }
+      process.stdout.write(`\nDefault: ${supportedBackends[0]}\n`);
+    }
     return;
   }
 
@@ -120,13 +192,13 @@ async function main() {
     }
   }
 
-  // Create backend session based on selected backend
-  const backendSession = createBackendSession(cliArgs.backend, {
-    threadOptions: cliArgs.threadOptions,
+  // Create backend session using cli2sdk with generic provider
+  const backendSession = new Cli2SdkSession(cliArgs.backend, {
     initialImages: cliArgs.initialImages,
     cwd: CLI_PROJECT_PATH,
     initialHistory: fromHistory.history,
     resumeSessionId: fromHistory.sessionId,
+    configFile: cliArgs.configFile,
   });
 
   log(`Using backend: ${cliArgs.backend}`);
@@ -190,16 +262,22 @@ async function main() {
   }
 }
 
-/**
- * Create a backend session based on the selected backend type.
- */
-function createBackendSession(backend, options) {
-  // Use cli2sdk for all backends including codex
-  return new Cli2SdkSession(backend, options);
+function extractConfigFileFromArgv(argv) {
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--config-file") {
+      return argv[i + 1];
+    }
+    if (arg.startsWith("--config-file=")) {
+      return arg.slice("--config-file=".length);
+    }
+  }
+  return undefined;
 }
 
-function parseCliArgs() {
-  const argv = hideBin(process.argv);
+export function parseCliArgs(argvInput = process.argv) {
+  const rawArgv = Array.isArray(argvInput) ? argvInput : process.argv;
+  const argv = hideBin(rawArgv);
   const separatorIndex = argv.indexOf("--");
   
   // When no separator, parse all args first to check for conductor-specific options
@@ -211,6 +289,10 @@ function parseCliArgs() {
   const listBackendsWithoutSeparator = separatorIndex === -1 && argv.includes("--list-backends");
   const helpWithoutSeparator = separatorIndex === -1 && (argv.includes("--help") || argv.includes("-h"));
 
+  const configFileFromArgs = extractConfigFileFromArgv(argv);
+  const allowCliList = loadAllowCliList(configFileFromArgs);
+  const supportedBackends = Object.keys(allowCliList);
+
   const conductorArgs = yargs(conductorArgv)
     .scriptName(CLI_NAME)
     .usage("Usage: $0 [--backend <name>] -- [backend options and prompt]")
@@ -218,9 +300,8 @@ function parseCliArgs() {
     .option("backend", {
       alias: "b",
       type: "string",
-      describe: `Backend to use (${SUPPORTED_BACKENDS.join(", ")})`,
-      default: DEFAULT_BACKEND,
-      choices: SUPPORTED_BACKENDS,
+      describe: `Backend to use (loaded from config: ${supportedBackends.join(", ") || "none configured"})`,
+      ...(supportedBackends.length > 0 ? { choices: supportedBackends } : {}),
     })
     .option("list-backends", {
       type: "boolean",
@@ -269,13 +350,14 @@ function parseCliArgs() {
 
   // Handle help early
   if (helpWithoutSeparator) {
+    const defaultBackend = supportedBackends[0] || "none";
     process.stdout.write(`${CLI_NAME} - Conductor-aware AI coding agent runner
 
 Usage: ${CLI_NAME} [options] -- [backend options and prompt]
 
 Options:
-  -b, --backend <name>  Backend to use (${SUPPORTED_BACKENDS.join(", ")}) [default: ${DEFAULT_BACKEND}]
-  --list-backends       List available backends and exit
+  -b, --backend <name>  Backend to use (from config: ${supportedBackends.join(", ") || "none configured"}) [default: ${defaultBackend}]
+  --list-backends       List available backends from config and exit
   --config-file <path>  Path to Conductor config file
   --poll-interval <ms>  Polling interval when waiting for Conductor messages
   -t, --title <text>    Optional task title shown in the app task list
@@ -284,17 +366,19 @@ Options:
   -v, --version         Show Conductor CLI version and exit
   -h, --help            Show this help message
 
+Config file format (~/.conductor/config.yaml):
+  allow_cli_list:
+    codex: codex --dangerously-bypass-approvals-and-sandbox
+    claude: claude --dangerously-skip-permissions
+
 Examples:
-  ${CLI_NAME} -- "fix the bug"                    # Use default backend (codex)
+  ${CLI_NAME} -- "fix the bug"                    # Use default backend
   ${CLI_NAME} --backend claude -- "fix the bug"   # Use Claude CLI backend
-  ${CLI_NAME} --backend tmates -- "fix the bug"   # Use TMates CLI backend
-  ${CLI_NAME} --backend copilot -- "fix the bug"  # Use Copilot CLI backend
+  ${CLI_NAME} --list-backends                     # Show configured backends
   ${CLI_NAME} --config-file ~/.conductor/config.yaml -- "fix the bug"
-  ${CLI_NAME} --backend codex --from -- "continue"
-  ${CLI_NAME} --backend codex --from codex-session-id -- "continue"
 
 Environment:
-  CONDUCTOR_BACKEND     Default backend (overrides codex)
+  CONDUCTOR_BACKEND     Default backend
   CONDUCTOR_PROJECT_ID  Project ID to attach to
   CONDUCTOR_TASK_ID     Attach to existing task instead of creating new one
 `);
@@ -311,13 +395,7 @@ Environment:
     })
     .parse();
   
-  // Apply codex-specific defaults when using codex backend
-  const backend = conductorArgs.backend || DEFAULT_BACKEND;
-  if (backend === "codex") {
-    backendArgs.sandboxMode ||= "danger-full-access";
-    backendArgs.approvalPolicy ||= "never";
-    backendArgs.skipGitRepoCheck ||= true;
-  }
+  const backend = conductorArgs.backend || supportedBackends[0];
 
   const prompt = (backendArgs._ || []).map((part) => String(part)).join(" ").trim();
   const initialImages = normalizeArray(backendArgs.image || backendArgs.i).map((img) => String(img));
@@ -336,7 +414,6 @@ Environment:
     backend,
     initialPrompt: prompt || conductorArgs.prefill || "",
     initialImages,
-    threadOptions: deriveThreadOptions(backendArgs, CLI_PROJECT_PATH),
     pollIntervalMs,
     rawBackendArgs: backendArgv,
     taskTitle: resolveTaskTitle(conductorArgs.title),
@@ -355,73 +432,6 @@ function resolveTaskTitle(titleFlag) {
   return cwdName || "";
 }
 
-function deriveThreadOptions(codexArgs, defaultWorkingDirectory = CLI_PROJECT_PATH) {
-  const options = {};
-  const allowedKeys = new Set([
-    "model",
-    "sandboxMode",
-    "workingDirectory",
-    "skipGitRepoCheck",
-    "modelReasoningEffort",
-    "networkAccessEnabled",
-    "webSearchEnabled",
-    "approvalPolicy",
-  ]);
-
-  Object.entries(codexArgs || {}).forEach(([key, value]) => {
-    if (key === "_" || key === "$0") {
-      return;
-    }
-    const optionKey = mapCodexFlagToThreadOption(key);
-    if (allowedKeys.has(optionKey)) {
-      options[optionKey] = value;
-    }
-  });
-
-  if (codexArgs.fullAuto) {
-    options.sandboxMode ||= "workspace-write";
-    options.approvalPolicy ||= "on-request";
-  }
-
-  if (codexArgs.dangerouslyBypassApprovalsAndSandbox) {
-    options.sandboxMode = "danger-full-access";
-    options.approvalPolicy = "never";
-  }
-
-  if (!options.workingDirectory && defaultWorkingDirectory) {
-    options.workingDirectory = defaultWorkingDirectory;
-  }
-
-  return options;
-}
-
-function mapCodexFlagToThreadOption(flag) {
-  const normalized = toCamelCase(flag);
-  if (normalized === "sandbox") {
-    return "sandboxMode";
-  }
-  if (normalized === "askForApproval" || normalized === "approval") {
-    return "approvalPolicy";
-  }
-  if (normalized === "cd" || normalized === "c" || normalized === "workingDirectory") {
-    return "workingDirectory";
-  }
-  if (normalized === "search" || normalized === "webSearch") {
-    return "webSearchEnabled";
-  }
-  if (normalized === "networkAccess" || normalized === "network") {
-    return "networkAccessEnabled";
-  }
-  return normalized;
-}
-
-function toCamelCase(value) {
-  return String(value || "")
-     .replace(/^[\s-_]+|[\s-_]+$/g, "")
-     .replace(/[-_]+(.)/g, (_, chr) => (chr ? chr.toUpperCase() : ""))
-     .replace(/^[A-Z]/, (chr) => chr.toLowerCase());
-}
-
 function normalizeArray(value) {
   if (!value) {
     return [];
@@ -455,6 +465,16 @@ async function ensureTaskContext(conductor, opts) {
   }
 
   const session = await conductor.createTaskSession(payload);
+
+  // Auto-bind current path to project if not already bound
+  try {
+    await conductor.bindProjectPath(projectId);
+    log(`Bound current path to project ${projectId}`);
+  } catch (error) {
+    // Ignore binding errors - it's not critical
+    log(`Note: Could not bind path to project: ${error.message}`);
+  }
+
   return {
     taskId: session.task_id,
     appUrl: session.app_url || null,
@@ -467,6 +487,17 @@ async function resolveProjectId(conductor, explicit) {
     return explicit;
   }
 
+  // First, try to match project by current path
+  try {
+    const matchResult = await conductor.matchProjectByPath();
+    if (matchResult?.project_id) {
+      log(`Matched project ${matchResult.project_name || matchResult.project_id} by path ${matchResult.matched_path}`);
+      return matchResult.project_id;
+    }
+  } catch (error) {
+    log(`Unable to match project by path: ${error.message}`);
+  }
+
   try {
     const record = await conductor.getLocalProjectRecord();
     if (record?.project_id) {
@@ -509,19 +540,36 @@ function deriveTaskTitle(prompt, explicit, backend = "codex") {
 }
 
 /**
- * Cli2SdkSession - Backend session using cli2sdk providers (all backends including codex).
+ * Cli2SdkSession - Backend session using cli2sdk with generic provider.
+ * All CLI commands come from config - no provider-specific argument transformation.
  */
 class Cli2SdkSession {
   constructor(backend, options = {}) {
     this.backend = backend;
     this.options = options;
 
-    // For codex, pass threadOptions as config
-    const config = backend === "codex"
-      ? { provider: backend, codex: options.threadOptions }
-      : { provider: backend };
+    // Get CLI command: first from env var (set by daemon), then from config file
+    const allowCliList = options.configFile ? loadAllowCliList(options.configFile) : DEFAULT_ALLOW_CLI_LIST;
+    const cliCommand = CUSTOM_CLI_COMMAND || allowCliList[backend] || backend;
+    const parts = cliCommand.split(/\s+/);
+    const command = parts[0];
+    const args = parts.slice(1);
+
+    // Load envs config and normalize proxy envs
+    const envConfig = loadEnvConfig(options.configFile);
+    const proxyEnv = proxyToEnv(envConfig);
+    const cliEnv = envConfig && typeof envConfig === "object" ? { ...envConfig, ...proxyEnv } : proxyEnv;
+    if (Object.keys(proxyEnv).length > 0) {
+      log(`Using proxy: ${proxyEnv.http_proxy || proxyEnv.https_proxy || proxyEnv.all_proxy}`);
+    }
+
+    log(`Using CLI command for ${backend}: ${cliCommand}`);
+
+    this.sdk = cli2sdk({
+      provider: "generic",
+      generic: { command, args, inputFormat: "text", env: cliEnv },
+    });
 
-    this.sdk = cli2sdk(config);
     this.sessionId = options.resumeSessionId || `${backend}-${Date.now()}`;
     this.history = Array.isArray(options.initialHistory) ? [...options.initialHistory] : [];
   }
@@ -531,7 +579,7 @@ class Cli2SdkSession {
   }
 
   get threadOptions() {
-    return this.backend === "codex" ? this.options.threadOptions : { model: this.backend };
+    return { model: this.backend };
   }
 
   async runTurn(promptText, { useInitialImages = false } = {}) {
@@ -547,19 +595,9 @@ class Cli2SdkSession {
     log(`[${this.backend}] Running prompt: ${promptText.slice(0, 100)}...`);
 
     try {
-      if (this.backend === "codex" && useInitialImages && this.options.initialImages?.length > 0) {
-        log("[codex] Initial images are not supported via codex CLI; ignoring images.");
-      }
-
-      const cwd =
-        this.backend === "codex" && this.options.threadOptions?.workingDirectory
-          ? this.options.threadOptions.workingDirectory
-          : this.options.cwd;
-
       const result = await this.sdk.run(promptText, {
-        provider: this.backend,
         history: this.history,
-        cwd,
+        cwd: this.options.cwd,
       });
 
       // Update history for multi-turn conversations
@@ -689,6 +727,14 @@ class ConductorClient {
     return this.callTool("get_local_project_id", this.injectProjectPath({}));
   }
 
+  async matchProjectByPath() {
+    return this.callTool("match_project_by_path", this.injectProjectPath({}));
+  }
+
+  async bindProjectPath(projectId) {
+    return this.callTool("bind_project_path", this.injectProjectPath({ project_id: projectId }));
+  }
+
   async callTool(name, args) {
     const result = await this.client.callTool({
       name,
@@ -896,8 +942,23 @@ function logBackendReply(backend, text, { usage, replyTo }) {
   log(`${backend} reply (${replyTo}): ${text}${usageSuffix}`);
 }
 
-main().catch((error) => {
-  const ts = new Date().toLocaleString("sv-SE", { timeZone: "Asia/Shanghai" }).replace(" ", "T");
-  process.stderr.write(`[${CLI_NAME} ${ts}] failed: ${error.stack || error.message}\n`);
-  process.exitCode = 1;
-});
+function isDirectRun() {
+  try {
+    if (!process.argv[1]) {
+      return false;
+    }
+    const argvPath = fs.realpathSync(process.argv[1]);
+    const scriptPath = fs.realpathSync(__filename);
+    return argvPath === scriptPath;
+  } catch {
+    return false;
+  }
+}
+
+if (isDirectRun()) {
+  main().catch((error) => {
+    const ts = new Date().toLocaleString("sv-SE", { timeZone: "Asia/Shanghai" }).replace(" ", "T");
+    process.stderr.write(`[${CLI_NAME} ${ts}] failed: ${error.stack || error.message}\n`);
+    process.exitCode = 1;
+  });
+}

package/bin/conductor.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+
+/**
+ * conductor - Main CLI entry point with subcommand routing.
+ *
+ * Subcommands:
+ *   fire    - Run AI coding agents with Conductor integration
+ *   daemon  - Start long-running daemon for task orchestration
+ *   config  - Interactive configuration setup
+ */
+
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import yargs from "yargs/yargs";
+import { hideBin } from "yargs/helpers";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const require = createRequire(import.meta.url);
+const PKG_ROOT = path.join(__dirname, "..");
+
+const pkgJson = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, "package.json"), "utf-8"));
+
+// Parse command line arguments
+const argv = process.argv.slice(2);
+
+// If no arguments or help flag, show help
+if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h") {
+  showHelp();
+  process.exit(0);
+}
+
+// If version flag, show version
+if (argv[0] === "--version" || argv[0] === "-v") {
+  console.log(`conductor version ${pkgJson.version}`);
+  process.exit(0);
+}
+
+// Get the subcommand
+const subcommand = argv[0];
+
+// Valid subcommands
+const validSubcommands = ["fire", "daemon", "config"];
+
+if (!validSubcommands.includes(subcommand)) {
+  console.error(`Error: Unknown subcommand '${subcommand}'`);
+  console.error(`Valid subcommands: ${validSubcommands.join(", ")}`);
+  console.error(`Run 'conductor --help' for usage information.`);
+  process.exit(1);
+}
+
+// Route to the appropriate subcommand
+const subcommandArgs = argv.slice(1);
+
+// Set environment variable to track the CLI name for logging
+process.env.CONDUCTOR_CLI_NAME = `conductor ${subcommand}`;
+
+// Import and execute the subcommand
+const subcommandPath = path.join(__dirname, `conductor-${subcommand}.js`);
+
+if (!fs.existsSync(subcommandPath)) {
+  console.error(`Error: Subcommand implementation not found: ${subcommandPath}`);
+  process.exit(1);
+}
+
+// Replace process.argv to pass the correct arguments to the subcommand
+process.argv = [process.argv[0], subcommandPath, ...subcommandArgs];
+
+// Dynamically import and execute the subcommand
+import(subcommandPath).catch((error) => {
+  console.error(`Error loading subcommand '${subcommand}': ${error.message}`);
+  process.exit(1);
+});
+
+function showHelp() {
+  console.log(`conductor - Conductor CLI tool
+
+Usage: conductor <subcommand> [options]
+
+Subcommands:
+  fire      Run AI coding agents with Conductor integration
+  daemon    Start long-running daemon for task orchestration
+  config    Interactive configuration setup
+
+Options:
+  -h, --help     Show this help message
+  -v, --version  Show version information
+
+Examples:
+  conductor fire -- "fix the bug"
+  conductor fire --backend claude -- "add feature"
+  conductor daemon --config-file ~/.conductor/config.yaml
+  conductor config
+
+For subcommand-specific help:
+  conductor fire --help
+  conductor daemon --help
+  conductor config --help
+
+Version: ${pkgJson.version}
+`);
+}

package/package.json

@@ -1,12 +1,9 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "type": "module",
   "bin": {
-    "conductor-cli": "bin/conductor-fire.js",
-    "conductor-fire": "bin/conductor-fire.js",
-    "conductor-daemon": "bin/conductor-daemon.js",
-    "conductor-config": "bin/conductor-config.js"
+    "conductor": "bin/conductor.js"
   },
   "files": [
     "bin",
@@ -22,7 +19,6 @@
     "@love-moon/cli2sdk": "0.1.0",
     "@love-moon/conductor-sdk": "0.1.0",
     "@modelcontextprotocol/sdk": "^1.20.2",
-    "@openai/codex-sdk": "^0.58.0",
     "dotenv": "^16.4.5",
     "enquirer": "^2.4.1",
     "js-yaml": "^4.1.1",

package/src/daemon.js

@@ -42,6 +42,20 @@ function getUserConfig(configFilePath) {
   return {};
 }
 
+// Default CLI commands for supported backends
+const DEFAULT_CLI_LIST = {
+  codex: "codex --dangerously-bypass-approvals-and-sandbox",
+  claude: "claude --dangerously-skip-permissions",
+};
+
+function getAllowCliList(userConfig) {
+  // If user has configured allow_cli_list, use it; otherwise use defaults
+  if (userConfig.allow_cli_list && typeof userConfig.allow_cli_list === "object") {
+    return userConfig.allow_cli_list;
+  }
+  return DEFAULT_CLI_LIST;
+}
+
 export function startDaemon(config = {}, deps = {}) {
   let fileConfig;
   try {
@@ -83,6 +97,10 @@ export function startDaemon(config = {}, deps = {}) {
     path.join(process.env.HOME || "/tmp", "ws");
   const CLI_PATH_VAL = config.CLI_PATH || CLI_PATH;
 
+  // Get allow_cli_list from config
+  const ALLOW_CLI_LIST = getAllowCliList(userConfig);
+  const SUPPORTED_BACKENDS = Object.keys(ALLOW_CLI_LIST);
+
   const spawnFn = deps.spawn || spawn;
   const mkdirSyncFn = deps.mkdirSync || fs.mkdirSync;
   const writeFileSyncFn = deps.writeFileSync || fs.writeFileSync;
@@ -171,6 +189,7 @@ export function startDaemon(config = {}, deps = {}) {
   log(`Workspace: ${WORKSPACE_ROOT}`);
   log(`CLI Path: ${CLI_PATH_VAL}`);
   log(`Daemon Name: ${AGENT_NAME}`);
+  log(`Supported Backends: ${SUPPORTED_BACKENDS.join(", ")}`);
 
   const sdkConfig = new ConductorConfig({
     agentToken: AGENT_TOKEN,
@@ -181,6 +200,7 @@ export function startDaemon(config = {}, deps = {}) {
   const client = new ConductorWebSocketClient(sdkConfig, {
     extraHeaders: {
       "x-conductor-host": AGENT_NAME,
+      "x-conductor-backends": SUPPORTED_BACKENDS.join(","),
     },
   });
 
@@ -203,7 +223,35 @@ export function startDaemon(config = {}, deps = {}) {
     }
   }
 
-  function handleCreateTask(payload) {
+  async function getProjectLocalPath(projectId) {
+    try {
+      const response = await fetchFn(`${BACKEND_HTTP}/api/projects/${projectId}`, {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${AGENT_TOKEN}`,
+          Accept: "application/json",
+        },
+      });
+      if (!response.ok) {
+        return null;
+      }
+      const project = await response.json();
+      if (!project.metadata) {
+        return null;
+      }
+      const metadata = typeof project.metadata === "string" ? JSON.parse(project.metadata) : project.metadata;
+      const localPaths = metadata.localPaths;
+      if (!localPaths || typeof localPaths !== "object") {
+        return null;
+      }
+      return localPaths[AGENT_NAME] || null;
+    } catch (error) {
+      log(`Failed to get project local path: ${error.message}`);
+      return null;
+    }
+  }
+
+  async function handleCreateTask(payload) {
     const { task_id: taskId, project_id: projectId, backend_type: backendType, initial_content: initialContent } =
       payload || {};
 
@@ -212,8 +260,29 @@ export function startDaemon(config = {}, deps = {}) {
       return;
     }
 
+    // Validate and get CLI command for the backend
+    const effectiveBackend = backendType || SUPPORTED_BACKENDS[0];
+    if (!SUPPORTED_BACKENDS.includes(effectiveBackend)) {
+      logError(`Unsupported backend: ${effectiveBackend}. Supported: ${SUPPORTED_BACKENDS.join(", ")}`);
+      client
+        .sendJson({
+          type: "task_status_update",
+          payload: {
+            task_id: taskId,
+            project_id: projectId,
+            status: "FAILED",
+            summary: `Unsupported backend: ${effectiveBackend}`,
+          },
+        })
+        .catch(() => {});
+      return;
+    }
+
+    const cliCommand = ALLOW_CLI_LIST[effectiveBackend];
+
     log("");
-    log(`Creating task ${taskId} for project ${projectId} (${backendType})`);
+    log(`Creating task ${taskId} for project ${projectId} (${effectiveBackend})`);
+    log(`CLI command: ${cliCommand}`);
     client
       .sendJson({
         type: "task_status_update",
@@ -227,12 +296,27 @@ export function startDaemon(config = {}, deps = {}) {
         logError(`Failed to report task status (CREATED) for ${taskId}: ${err?.message || err}`);
       });
 
-    const taskDir = path.join(WORKSPACE_ROOT, projectId, taskId);
-    mkdirSyncFn(taskDir, { recursive: true });
+    // Check if project has a bound local path for this daemon
+    const boundPath = await getProjectLocalPath(projectId);
+    let taskDir;
+    let logPath;
+
+    if (boundPath) {
+      // Use the bound path directly (don't create subdirectory)
+      taskDir = boundPath;
+      log(`Using project bound path: ${taskDir}`);
+      // Create log file in the bound path
+      logPath = path.join(taskDir, `.conductor-${taskId}.log`);
+    } else {
+      // Use default workspace structure
+      taskDir = path.join(WORKSPACE_ROOT, projectId, taskId);
+      mkdirSyncFn(taskDir, { recursive: true });
+      logPath = path.join(taskDir, ".conductor.log");
+    }
 
     const args = [];
-    if (backendType) {
-      args.push("--backend", backendType);
+    if (effectiveBackend) {
+      args.push("--backend", effectiveBackend);
     }
     if (initialContent) {
       args.push("--prefill", initialContent);
@@ -240,7 +324,6 @@ export function startDaemon(config = {}, deps = {}) {
     // Explicitly separate conductor flags from backend args so they don't leak into messages
     args.push("--");
 
-    const logPath = path.join(taskDir, ".conductor.log");
     let logStream;
     try {
       logStream = createWriteStreamFn(logPath, { flags: "a" });
@@ -255,6 +338,7 @@ export function startDaemon(config = {}, deps = {}) {
       ...process.env,
       CONDUCTOR_PROJECT_ID: projectId,
       CONDUCTOR_TASK_ID: taskId,
+      CONDUCTOR_CLI_COMMAND: cliCommand,
     };
     if (config.CONFIG_FILE) {
       env.CONDUCTOR_CONFIG = config.CONFIG_FILE;