@love-moon/conductor-cli 0.1.4 → 0.2.1

package/bin/conductor-config.js

@@ -5,47 +5,308 @@ import os from "node:os";
 import path from "node:path";
 import process from "node:process";
 import readline from "node:readline/promises";
+import { execSync } from "node:child_process";
+import yargs from "yargs/yargs";
+import { hideBin } from "yargs/helpers";
 
 const CONFIG_DIR = path.join(os.homedir(), ".conductor");
 const CONFIG_FILE = path.join(CONFIG_DIR, "config.yaml");
 
+// 市面上主流 Coding CLI 配置
+// 格式: { name: { command: string, description: string, execArgs?: string } }
+const DEFAULT_CLIs = {
+  claude: {
+    command: "claude",
+    execArgs: "--dangerously-skip-permissions",
+    description: "Anthropic Claude CLI"
+  },
+  codex: {
+    command: "codex",
+    execArgs: "exec --dangerously-bypass-approvals-and-sandbox --skip-git-repo-check",
+    description: "OpenAI Codex CLI"
+  },
+  copilot: {
+    command: "copilot",
+    execArgs: "--allow-all-paths --allow-all-tools -i",
+    description: "GitHub Copilot CLI"
+  },
+  gemini: {
+    command: "gemini",
+    execArgs: "",
+    description: "Google Gemini CLI"
+  },
+  opencode: {
+    command: "opencode",
+    execArgs: "",
+    description: "OpenCode CLI"
+  },
+  kimi: {
+    command: "kimi",
+    execArgs: "--yolo --print --prompt",
+    description: "Kimi CLI"
+  },
+  aider: {
+    command: "aider",
+    execArgs: "",
+    description: "Aider AI Pair Programming"
+  },
+  goose: {
+    command: "goose",
+    execArgs: "",
+    description: "Goose AI Agent CLI"
+  },
+};
+
 const backendUrl =
   process.env.CONDUCTOR_BACKEND_URL ||
   process.env.BACKEND_URL ||
   "https://conductor-ai.top";
 
-const websocketUrl =
-  process.env.CONDUCTOR_WS_URL || process.env.PUBLIC_WS_URL || "";
+// ANSI 颜色代码
+const COLORS = {
+  yellow: "\x1b[33m",
+  green: "\x1b[32m",
+  cyan: "\x1b[36m",
+  reset: "\x1b[0m",
+  bold: "\x1b[1m"
+};
+
+function colorize(text, color) {
+  return `${COLORS[color] || ""}${text}${COLORS.reset}`;
+}
 
 async function main() {
-  if (fs.existsSync(CONFIG_FILE)) {
-    process.stderr.write(`Config already exists at ${CONFIG_FILE}. Remove it to recreate.\n`);
+  // 解析命令行参数
+  const argv = yargs(hideBin(process.argv))
+    .option("token", {
+      type: "string",
+      description: "Conductor token (optional, will prompt if not provided)"
+    })
+    .option("force", {
+      type: "boolean",
+      default: false,
+      description: "Overwrite existing config file"
+    })
+    .option("help", {
+      type: "boolean",
+      alias: "h",
+      description: "Show help"
+    })
+    .usage("Usage: conductor config [options]")
+    .example("conductor config", "Interactive configuration")
+    .example("conductor config --token <your-token>", "Configure with token")
+    .example("conductor config --token <token> --force", "Force overwrite existing config")
+    .help()
+    .argv;
+
+  // 检查配置文件是否存在
+  if (fs.existsSync(CONFIG_FILE) && !argv.force) {
+    process.stderr.write(
+      colorize(`Config already exists at ${CONFIG_FILE}. Use --force to overwrite.\n`, "yellow")
+    );
     process.exit(1);
   }
 
-  const token = await promptForToken();
+  // 获取 token
+  let token = argv.token;
   if (!token) {
-    process.stderr.write("No token provided. Aborting.\n");
-    process.exit(1);
+    token = await promptForToken();
+    if (!token) {
+      process.stderr.write(colorize("No token provided. Aborting.\n", "yellow"));
+      process.exit(1);
+    }
+  }
+
+  // 检测已安装的 CLI
+  const detectedCLIs = detectInstalledCLIs();
+
+  // 如果没有检测到任何 CLI，显示警告
+  if (detectedCLIs.length === 0) {
+    console.log("");
+    console.log(colorize("=".repeat(70), "yellow"));
+    console.log(colorize("⚠️  WARNING: No coding CLI detected!", "yellow"));
+    console.log(colorize("=".repeat(70), "yellow"));
+    console.log(colorize("", "yellow"));
+    console.log(colorize("Conductor requires at least one coding CLI to work properly.", "yellow"));
+    console.log(colorize("", "yellow"));
+    console.log(colorize("Please install one of the following CLIs first:", "yellow"));
+    console.log("");
+    
+    Object.entries(DEFAULT_CLIs).forEach(([key, info]) => {
+      console.log(`  • ${colorize(info.command, "cyan")} - ${info.description}`);
+    });
+    
+    console.log("");
+    console.log(colorize("After installing a CLI, run 'conductor config' again.", "yellow"));
+    console.log(colorize("=".repeat(70), "yellow"));
+    console.log("");
+    
+    // 询问是否继续创建配置
+    const shouldContinue = await promptYesNo(
+      "Do you want to continue creating the config anyway? (y/N): "
+    );
+    
+    if (!shouldContinue) {
+      process.exit(1);
+    }
+  } else {
+    // 显示检测到的 CLI
+    console.log("");
+    console.log(colorize("✓ Detected the following coding CLIs:", "green"));
+    detectedCLIs.forEach(cli => {
+      const info = DEFAULT_CLIs[cli];
+      console.log(`  • ${colorize(info.command, "cyan")} - ${info.description}`);
+    });
+    console.log("");
   }
 
+  // 创建配置目录
   fs.mkdirSync(CONFIG_DIR, { recursive: true });
 
+  // 构建配置内容
   const lines = [
     `agent_token: ${yamlQuote(token)}`,
     `backend_url: ${yamlQuote(backendUrl)}`,
+    "log_level: debug",
+    "",
+    "# Allowed coding CLIs",
+    "allow_cli_list:"
   ];
-  if (websocketUrl) {
-    lines.push(`websocket_url: ${yamlQuote(websocketUrl)}`);
+
+  // 添加检测到的 CLI 到配置
+  if (detectedCLIs.length > 0) {
+    detectedCLIs.forEach(cli => {
+      const info = DEFAULT_CLIs[cli];
+      const fullCommand = info.execArgs 
+        ? `${info.command} ${info.execArgs}` 
+        : info.command;
+      lines.push(`  ${cli}: ${fullCommand}`);
+    });
+  } else {
+    // 如果没有检测到任何 CLI，添加示例注释
+    lines.push("  # No CLI detected. Add your installed CLI here:");
+    Object.entries(DEFAULT_CLIs).slice(0, 3).forEach(([key, info]) => {
+      const fullCommand = info.execArgs 
+        ? `${info.command} ${info.execArgs}` 
+        : info.command;
+      lines.push(`  # ${key}: ${fullCommand}`);
+    });
   }
-  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", "");
+
+  lines.push(
+    "",
+    "# Uncomment to use custom envs, such as proxy.",
+    "# envs:",
+    "#   http_proxy: http://127.0.0.1:7890",
+    "#   https_proxy: http://127.0.0.1:7890",
+    "#   all_proxy: socks5://127.0.0.1:7890"
+  );
 
   fs.writeFileSync(CONFIG_FILE, lines.join("\n"), "utf-8");
-  process.stdout.write(`Wrote Conductor config to ${CONFIG_FILE}\n`);
+  
+  console.log(colorize(`✓ Wrote Conductor config to ${CONFIG_FILE}`, "green"));
+  
+  if (detectedCLIs.length === 0) {
+    console.log("");
+    console.log(colorize("⚠️  Remember to install a coding CLI before using Conductor!", "yellow"));
+  }
+}
+
+/**
+ * 检测系统中已安装的 CLI
+ * @returns {string[]} 已安装的 CLI key 列表
+ */
+function detectInstalledCLIs() {
+  const detected = [];
+  
+  for (const [key, info] of Object.entries(DEFAULT_CLIs)) {
+    if (isCommandAvailable(info.command)) {
+      detected.push(key);
+    }
+  }
+  
+  return detected;
+}
+
+/**
+ * 检查命令是否在系统 PATH 中可用
+ * @param {string} command - 命令名称
+ * @returns {boolean}
+ */
+function isCommandAvailable(command) {
+  try {
+    const platform = os.platform();
+    let checkCmd;
+    
+    if (platform === "win32") {
+      // Windows: 使用 where 命令
+      checkCmd = `where ${command}`;
+    } else {
+      // Unix/Linux/macOS: 使用 which 或 command -v
+      checkCmd = `command -v ${command}`;
+    }
+    
+    execSync(checkCmd, { 
+      stdio: "pipe",
+      timeout: 5000 
+    });
+    return true;
+  } catch (error) {
+    // 对于某些 CLI，可能有特定的检测方式
+    // 例如检查特定的配置文件或目录
+    return checkAlternativeInstallations(command);
+  }
+}
+
+/**
+ * 检查 CLI 的替代安装方式
+ * @param {string} command - 命令名称
+ * @returns {boolean}
+ */
+function checkAlternativeInstallations(command) {
+  // 检查常见的全局安装路径
+  const homeDir = os.homedir();
+  const platform = os.platform();
+  
+  const commonPaths = [];
+  
+  if (platform === "win32") {
+    commonPaths.push(
+      path.join(homeDir, "AppData", "Roaming", "npm", `${command}.cmd`),
+      path.join(homeDir, "AppData", "Local", "Programs", command, `${command}.exe`),
+      path.join("C:", "Program Files", command, `${command}.exe`),
+      path.join("C:", "Program Files (x86)", command, `${command}.exe`)
+    );
+  } else {
+    commonPaths.push(
+      `/usr/local/bin/${command}`,
+      `/opt/homebrew/bin/${command}`,
+      `/usr/bin/${command}`,
+      path.join(homeDir, ".local", "bin", command),
+      path.join(homeDir, ".cargo", "bin", command),
+      path.join(homeDir, ".npm-global", "bin", command),
+      `/opt/${command}/bin/${command}`
+    );
+  }
+  
+  // 特殊检查：Copilot CLI 可能是 gh copilot 扩展
+  if (command === "copilot" || command === "copilot-chat") {
+    try {
+      execSync("gh copilot --help", { stdio: "pipe", timeout: 5000 });
+      return true;
+    } catch {
+      // gh copilot 未安装
+    }
+  }
+  
+  // 检查文件是否存在
+  for (const checkPath of commonPaths) {
+    if (fs.existsSync(checkPath)) {
+      return true;
+    }
+  }
+  
+  return false;
 }
 
 async function promptForToken() {
@@ -64,6 +325,19 @@ async function promptForToken() {
   }
 }
 
+async function promptYesNo(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  try {
+    const answer = (await rl.question(question)).trim().toLowerCase();
+    return answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+}
+
 function yamlQuote(value) {
   return JSON.stringify(value);
 }

package/bin/conductor-daemon.js

@@ -6,6 +6,7 @@ import os from "node:os";
 import { spawn } from "node:child_process";
 import yargs from "yargs/yargs";
 import { hideBin } from "yargs/helpers";
+import yaml from "js-yaml";
 
 import { startDaemon } from "../src/daemon.js";
 
@@ -13,9 +14,85 @@ const argv = hideBin(process.argv);
 
 const CLI_NAME = process.env.CONDUCTOR_CLI_NAME || "conductor-daemon";
 
+function formatBeijingTimestampForFile(date = new Date()) {
+  const base = date
+    .toLocaleString("sv-SE", { timeZone: "Asia/Shanghai", hour12: false })
+    .replace(" ", "T")
+    .replace(/:/g, "-");
+  const millis = String(date.getMilliseconds()).padStart(3, "0");
+  return `${base}-${millis}`;
+}
+
+function loadUserConfig(configFilePath) {
+  try {
+    const home = os.homedir();
+    const configPath = configFilePath || path.join(home, ".conductor", "config.yaml");
+    if (!fs.existsSync(configPath)) {
+      return {};
+    }
+    const content = fs.readFileSync(configPath, "utf8");
+    const parsed = yaml.load(content);
+    if (parsed && typeof parsed === "object") {
+      return parsed;
+    }
+  } catch (_err) {
+    // Ignore config parse errors here; daemon will surface them later.
+  }
+  return {};
+}
+
+function expandHomePath(inputPath, homeDir) {
+  if (typeof inputPath !== "string" || !inputPath) {
+    return inputPath;
+  }
+  if (inputPath === "~") {
+    return homeDir;
+  }
+  if (inputPath.startsWith("~/") || inputPath.startsWith("~\\")) {
+    return path.join(homeDir, inputPath.slice(2));
+  }
+  return inputPath;
+}
+
+function resolveWorkspaceRoot(configFilePath) {
+  const userConfig = loadUserConfig(configFilePath);
+  const home = process.env.HOME || os.homedir() || "/tmp";
+  const workspaceRoot = process.env.CONDUCTOR_WS || userConfig.workspace || path.join(home, "ws");
+  return expandHomePath(workspaceRoot, home);
+}
+
+function findRunningDaemonPid(workspaceRoot) {
+  const lockFile = path.join(workspaceRoot, "daemon.pid");
+  if (!fs.existsSync(lockFile)) {
+    return null;
+  }
+  try {
+    const pid = parseInt(fs.readFileSync(lockFile, "utf8"), 10);
+    if (Number.isNaN(pid)) {
+      return null;
+    }
+    process.kill(pid, 0);
+    return pid;
+  } catch (err) {
+    if (err && err.code === "ESRCH") {
+      return null;
+    }
+    return pidFromLockFile(lockFile);
+  }
+}
+
+function pidFromLockFile(lockFile) {
+  try {
+    const pid = parseInt(fs.readFileSync(lockFile, "utf8"), 10);
+    return Number.isNaN(pid) ? null : pid;
+  } catch (_err) {
+    return null;
+  }
+}
+
 const args = yargs(argv)
   .scriptName(CLI_NAME)
-  .usage("Usage: $0 [--name <daemon-name>] [--clean-all] [--config-file <path>] [--nohup]")
+  .usage("Usage: $0 [--name <daemon-name>] [--clean-all] [--config-file <path>] [--nohup] [--force]")
   .option("name", {
     alias: "n",
     type: "string",
@@ -27,6 +104,11 @@ const args = yargs(argv)
     default: false,
     describe: "Run in background and write logs to ~/.conductor/logs/<timestamp>.log",
   })
+  .option("force", {
+    type: "boolean",
+    default: false,
+    describe: "Force start by stopping an existing daemon process if needed",
+  })
   .option("clean-all", {
     type: "boolean",
     default: false,
@@ -41,14 +123,24 @@ const args = yargs(argv)
     "Use custom config file and daemon name",
   )
   .example("$0 --nohup", "Run daemon in background with logfile")
+  .example("$0 --nohup --force", "Restart daemon in background by stopping the existing one")
   .help()
   .strict()
   .parse();
 
 if (args.nohup) {
+  const workspaceRoot = resolveWorkspaceRoot(args.configFile);
+  const runningPid = findRunningDaemonPid(workspaceRoot);
+  if (runningPid && !args.force) {
+    process.stderr.write(
+      `${CLI_NAME} detected an existing daemon (PID ${runningPid}). Use --force to restart.\n`,
+    );
+    process.exit(1);
+  }
+
   const logsDir = path.join(os.homedir(), ".conductor", "logs");
   fs.mkdirSync(logsDir, { recursive: true });
-  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const timestamp = formatBeijingTimestampForFile(new Date());
   const logPath = path.join(logsDir, `${timestamp}.log`);
   const filteredArgv = argv.filter((arg) => !(arg === "--nohup" || arg.startsWith("--nohup=")));
   const logFd = fs.openSync(logPath, "a");
@@ -66,4 +158,5 @@ startDaemon({
   NAME: args.name,
   CLEAN_ALL: args.cleanAll,
   CONFIG_FILE: args.configFile,
+  FORCE: args.force,
 });