@love-moon/conductor-cli 0.2.10 → 0.2.12

package/bin/conductor-update.js

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+
+/**
+ * conductor update - Check for and install updates to the CLI.
+ */
+
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import { execSync, spawn } from "node:child_process";
+import process from "node:process";
+import readline from "node:readline/promises";
+
+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"));
+const PACKAGE_NAME = pkgJson.name;
+const CURRENT_VERSION = pkgJson.version;
+
+// ANSI 颜色代码
+const COLORS = {
+  yellow: "\x1b[33m",
+  green: "\x1b[32m",
+  cyan: "\x1b[36m",
+  red: "\x1b[31m",
+  reset: "\x1b[0m",
+  bold: "\x1b[1m"
+};
+
+function colorize(text, color) {
+  return `${COLORS[color] || ""}${text}${COLORS.reset}`;
+}
+
+async function main() {
+  // 解析命令行参数
+  const args = process.argv.slice(2);
+  const forceUpdate = args.includes("--force") || args.includes("-f");
+  const skipConfirm = args.includes("--yes") || args.includes("-y");
+  const showHelp = args.includes("--help") || args.includes("-h");
+
+  if (showHelp) {
+    showHelpMessage();
+    process.exit(0);
+  }
+
+  console.log(colorize(`📦 ${PACKAGE_NAME}`, "cyan"));
+  console.log(`   Current version: ${CURRENT_VERSION}`);
+  console.log("");
+
+  // 检查远程最新版本
+  console.log("🔍 Checking for updates...");
+  
+  let latestVersion;
+  try {
+    latestVersion = await getLatestVersion();
+  } catch (error) {
+    console.error(colorize(`❌ Failed to check for updates: ${error.message}`, "red"));
+    process.exit(1);
+  }
+
+  console.log(`   Latest version:  ${latestVersion}`);
+  console.log("");
+
+  // 比较版本
+  if (!forceUpdate && !isNewerVersion(latestVersion, CURRENT_VERSION)) {
+    console.log(colorize("✅ You are already on the latest version!", "green"));
+    process.exit(0);
+  }
+
+  if (forceUpdate) {
+    console.log(colorize("⚡ Force update requested", "yellow"));
+  } else {
+    console.log(colorize(`⬆️  Update available: ${CURRENT_VERSION} → ${latestVersion}`, "green"));
+  }
+
+  console.log("");
+
+  // 确认更新
+  if (!skipConfirm) {
+    const shouldUpdate = await confirmUpdate(latestVersion);
+    if (!shouldUpdate) {
+      console.log("Update cancelled.");
+      process.exit(0);
+    }
+  }
+
+  // 执行更新
+  console.log("");
+  console.log(colorize("🚀 Installing update...", "cyan"));
+  console.log("");
+
+  try {
+    await performUpdate();
+    console.log("");
+    console.log(colorize("✅ Update completed successfully!", "green"));
+    console.log("");
+    console.log("   Run 'conductor --version' to verify the new version.");
+  } catch (error) {
+    console.error("");
+    console.error(colorize(`❌ Update failed: ${error.message}`, "red"));
+    console.error("");
+    console.error("   You can try updating manually with:");
+    console.error(`   npm install -g ${PACKAGE_NAME}@latest`);
+    process.exit(1);
+  }
+}
+
+async function getLatestVersion() {
+  return new Promise((resolve, reject) => {
+    // 使用 npm view 获取最新版本
+    try {
+      const result = execSync(`npm view ${PACKAGE_NAME} version --json`, {
+        encoding: "utf-8",
+        timeout: 10000,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      
+      // npm view 返回的是带引号的字符串 JSON
+      const version = JSON.parse(result.trim());
+      resolve(version);
+    } catch (error) {
+      // 如果失败，尝试从 registry API 获取
+      fetchLatestFromRegistry()
+        .then(resolve)
+        .catch(reject);
+    }
+  });
+}
+
+async function fetchLatestFromRegistry() {
+  return new Promise((resolve, reject) => {
+    const https = require("https");
+    const url = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+    
+    https.get(url, { timeout: 10000 }, (res) => {
+      let data = "";
+      
+      res.on("data", (chunk) => {
+        data += chunk;
+      });
+      
+      res.on("end", () => {
+        try {
+          const json = JSON.parse(data);
+          if (json.version) {
+            resolve(json.version);
+          } else {
+            reject(new Error("Invalid response from registry"));
+          }
+        } catch (error) {
+          reject(new Error(`Failed to parse registry response: ${error.message}`));
+        }
+      });
+    }).on("error", (error) => {
+      reject(new Error(`Network error: ${error.message}`));
+    }).on("timeout", () => {
+      reject(new Error("Request timed out"));
+    });
+  });
+}
+
+function isNewerVersion(latest, current) {
+  // 简单的版本比较
+  const parseVersion = (v) => v.replace(/^v/, "").split(".").map(Number);
+  
+  const latestParts = parseVersion(latest);
+  const currentParts = parseVersion(current);
+  
+  for (let i = 0; i < Math.max(latestParts.length, currentParts.length); i++) {
+    const l = latestParts[i] || 0;
+    const c = currentParts[i] || 0;
+    
+    if (l > c) return true;
+    if (l < c) return false;
+  }
+  
+  return false; // 版本相同
+}
+
+async function confirmUpdate(version) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  
+  try {
+    const answer = await rl.question(
+      colorize(`Do you want to update to version ${version}? (Y/n): `, "yellow")
+    );
+    const normalized = answer.trim().toLowerCase();
+    return normalized === "" || normalized === "y" || normalized === "yes";
+  } finally {
+    rl.close();
+  }
+}
+
+async function performUpdate() {
+  return new Promise((resolve, reject) => {
+    // 检测使用的包管理器
+    const packageManager = detectPackageManager();
+    console.log(`   Using package manager: ${colorize(packageManager, "cyan")}`);
+    console.log("");
+    
+    let cmd, args;
+    
+    switch (packageManager) {
+      case "pnpm":
+        cmd = "pnpm";
+        args = ["add", "-g", `${PACKAGE_NAME}@latest`];
+        break;
+      case "yarn":
+        cmd = "yarn";
+        args = ["global", "add", `${PACKAGE_NAME}@latest`];
+        break;
+      case "npm":
+      default:
+        cmd = "npm";
+        args = ["install", "-g", `${PACKAGE_NAME}@latest`];
+        break;
+    }
+    
+    console.log(`   Running: ${colorize(`${cmd} ${args.join(" ")}`, "cyan")}`);
+    console.log("");
+    
+    const child = spawn(cmd, args, {
+      stdio: "inherit",
+      shell: true
+    });
+    
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Exit code ${code}`));
+      }
+    });
+    
+    child.on("error", (error) => {
+      reject(error);
+    });
+  });
+}
+
+function detectPackageManager() {
+  // 通过分析 conductor 命令的路径来推断包管理器
+  try {
+    const conductorPath = execSync("which conductor || where conductor", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "ignore"]
+    }).trim();
+    
+    if (conductorPath.includes("pnpm")) {
+      return "pnpm";
+    }
+    if (conductorPath.includes("yarn")) {
+      return "yarn";
+    }
+    if (conductorPath.includes(".npm") || conductorPath.includes("npm")) {
+      return "npm";
+    }
+  } catch {
+    // 忽略错误，使用默认检测
+  }
+  
+  // 检查哪个包管理器可用
+  try {
+    execSync("pnpm --version", { stdio: "pipe" });
+    return "pnpm";
+  } catch {
+    // pnpm 不可用
+  }
+  
+  try {
+    execSync("yarn --version", { stdio: "pipe" });
+    return "yarn";
+  } catch {
+    // yarn 不可用
+  }
+  
+  return "npm"; // 默认使用 npm
+}
+
+function showHelpMessage() {
+  console.log(`conductor update - Update the CLI to the latest version
+
+Usage: conductor update [options]
+
+Options:
+  -f, --force    Force update even if already on latest version
+  -y, --yes      Skip confirmation prompt
+  -h, --help     Show this help message
+
+Examples:
+  conductor update          Check for updates and prompt to install
+  conductor update --yes    Update without prompting
+  conductor update --force  Force reinstall the latest version
+`);
+}
+
+main().catch((error) => {
+  console.error(colorize(`Unexpected error: ${error?.message || error}`, "red"));
+  process.exit(1);
+});

package/bin/conductor.js

@@ -4,9 +4,10 @@
  * 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
+ *   fire     - Run AI coding agents with Conductor integration
+ *   daemon   - Start long-running daemon for task orchestration
+ *   config   - Interactive configuration setup
+ *   update   - Update the CLI to the latest version
  */
 
 import { fileURLToPath } from "node:url";
@@ -42,7 +43,7 @@ if (argv[0] === "--version" || argv[0] === "-v") {
 const subcommand = argv[0];
 
 // Valid subcommands
-const validSubcommands = ["fire", "daemon", "config"];
+const validSubcommands = ["fire", "daemon", "config", "update"];
 
 if (!validSubcommands.includes(subcommand)) {
   console.error(`Error: Unknown subcommand '${subcommand}'`);
@@ -83,6 +84,7 @@ Subcommands:
   fire      Run AI coding agents with Conductor integration
   daemon    Start long-running daemon for task orchestration
   config    Interactive configuration setup
+  update    Update the CLI to the latest version
 
 Options:
   -h, --help     Show this help message
@@ -93,11 +95,13 @@ Examples:
   conductor fire --backend claude -- "add feature"
   conductor daemon --config-file ~/.conductor/config.yaml
   conductor config
+  conductor update
 
 For subcommand-specific help:
   conductor fire --help
   conductor daemon --help
   conductor config --help
+  conductor update --help
 
 Version: ${pkgJson.version}
 `);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "type": "module",
   "bin": {
     "conductor": "bin/conductor.js"
@@ -16,8 +16,8 @@
     "test": "node --test"
   },
   "dependencies": {
-    "@love-moon/tui-driver": "0.2.10",
-    "@love-moon/conductor-sdk": "0.2.10",
+    "@love-moon/tui-driver": "0.2.12",
+    "@love-moon/conductor-sdk": "0.2.12",
     "dotenv": "^16.4.5",
     "enquirer": "^2.4.1",
     "js-yaml": "^4.1.1",

package/src/daemon.js

@@ -14,15 +14,35 @@ dotenv.config();
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const CLI_PATH = path.resolve(__dirname, "..", "bin", "conductor-fire.js");
+const DAEMON_LOG_DIR = path.join(os.homedir(), ".conductor", "logs");
+const DAEMON_LOG_PATH = path.join(DAEMON_LOG_DIR, "conductor-daemon.log");
+const PLAN_LIMIT_MESSAGES = {
+  manual_fire_active_task: "Free plan limit reached: only 1 active fire task is allowed.",
+  app_active_task: "Free plan limit reached: only 1 active app task is allowed.",
+  daemon_active_connection: "Free plan limit reached: only 1 active daemon connection is allowed.",
+};
+
+function appendDaemonLog(line) {
+  try {
+    fs.mkdirSync(DAEMON_LOG_DIR, { recursive: true });
+    fs.appendFileSync(DAEMON_LOG_PATH, line);
+  } catch {
+    // ignore file log errors
+  }
+}
 
 function log(message) {
   const ts = new Date().toLocaleString("sv-SE", { timeZone: "Asia/Shanghai" }).replace(" ", "T");
-  process.stdout.write(`[conductor-daemon ${ts}] ${message}\n`);
+  const line = `[conductor-daemon ${ts}] ${message}\n`;
+  process.stdout.write(line);
+  appendDaemonLog(line);
 }
 
 function logError(message) {
   const ts = new Date().toLocaleString("sv-SE", { timeZone: "Asia/Shanghai" }).replace(" ", "T");
-  process.stderr.write(`[conductor-daemon ${ts}] ${message}\n`);
+  const line = `[conductor-daemon ${ts}] ${message}\n`;
+  process.stderr.write(line);
+  appendDaemonLog(line);
 }
 
 function getUserConfig(configFilePath) {
@@ -42,6 +62,51 @@ function getUserConfig(configFilePath) {
   return {};
 }
 
+function normalizePlanLimitType(limitType) {
+  if (typeof limitType !== "string") {
+    return null;
+  }
+  const normalized = limitType.trim().toLowerCase();
+  if (!normalized) {
+    return null;
+  }
+  if (normalized === "free_daemon_connection" || normalized === "free-daemon-limit") {
+    return "daemon_active_connection";
+  }
+  return normalized;
+}
+
+function inferPlanLimitMessage(text) {
+  if (typeof text !== "string" || !text.trim()) {
+    return null;
+  }
+  const lower = text.trim().toLowerCase();
+  if (lower.includes("one active manual fire task")) {
+    return PLAN_LIMIT_MESSAGES.manual_fire_active_task;
+  }
+  if (lower.includes("one active app task")) {
+    return PLAN_LIMIT_MESSAGES.app_active_task;
+  }
+  if (lower.includes("one active daemon connection")) {
+    return PLAN_LIMIT_MESSAGES.daemon_active_connection;
+  }
+  if (lower.includes("free plan task limit reached")) {
+    return "Free plan task limit reached: only 1 active fire task and 1 active app task are allowed.";
+  }
+  return null;
+}
+
+function getPlanLimitMessage(payload) {
+  if (!payload || typeof payload !== "object") {
+    return null;
+  }
+  const normalizedType = normalizePlanLimitType(payload.limit_type);
+  if (normalizedType && PLAN_LIMIT_MESSAGES[normalizedType]) {
+    return PLAN_LIMIT_MESSAGES[normalizedType];
+  }
+  return inferPlanLimitMessage(payload.message) || inferPlanLimitMessage(payload.error);
+}
+
 // Default CLI commands for supported backends
 const DEFAULT_CLI_LIST = {
   codex: "codex --dangerously-bypass-approvals-and-sandbox",
@@ -478,6 +543,22 @@ export function startDaemon(config = {}, deps = {}) {
   }
 
   function handleEvent(event) {
+    if (event.type === "error") {
+      const payload = event?.payload && typeof event.payload === "object" ? event.payload : {};
+      const planLimitMessage = getPlanLimitMessage(payload);
+      if (planLimitMessage) {
+        logError(planLimitMessage);
+        return;
+      }
+      const backendMessage = typeof payload.message === "string" ? payload.message.trim() : "";
+      if (backendMessage) {
+        logError(`Backend error: ${backendMessage}`);
+      } else {
+        logError("Backend returned an error event");
+      }
+      return;
+    }
+
     if (event.type === "create_task") {
       handleCreateTask(event.payload);
       return;

package/src/fire/history.js

@@ -125,6 +125,73 @@ export async function selectHistorySession(provider, options = {}) {
   return selected || null;
 }
 
+export async function findSessionPath(provider, sessionId, options = {}) {
+  const normalizedProvider = String(provider || "").trim().toLowerCase();
+  if (normalizedProvider === "codex") {
+    return findCodexSessionPath(sessionId, options);
+  }
+  if (normalizedProvider === "claude") {
+    return findClaudeSessionPath(sessionId, options);
+  }
+  if (normalizedProvider === "copilot") {
+    return findCopilotSessionPath(sessionId, options);
+  }
+  throw new Error(`Unsupported provider: ${provider}`);
+}
+
+export async function findCodexSessionPath(sessionId, options = {}) {
+  const normalizedSessionId = normalizeSessionId(sessionId);
+  if (!normalizedSessionId) {
+    return null;
+  }
+  const homeDir = resolveHomeDir(options);
+  const sessionsDir = options.codexSessionsDir || path.join(homeDir, ".codex", "sessions");
+  return findCodexSessionFile(sessionsDir, normalizedSessionId);
+}
+
+export async function findClaudeSessionPath(sessionId, options = {}) {
+  const normalizedSessionId = normalizeSessionId(sessionId);
+  if (!normalizedSessionId) {
+    return null;
+  }
+
+  const homeDir = resolveHomeDir(options);
+  const projectsDir = options.claudeProjectsDir || path.join(homeDir, ".claude", "projects");
+  const sessionEntries = await findClaudeSessionEntries(projectsDir, normalizedSessionId);
+  if (sessionEntries.length > 0) {
+    return sessionEntries[0]?.source || null;
+  }
+
+  const tasksDir = options.claudeTasksDir || path.join(homeDir, ".claude", "tasks");
+  const directTaskDir = path.join(tasksDir, normalizedSessionId);
+  if (await pathExists(directTaskDir, "directory")) {
+    return directTaskDir;
+  }
+
+  return null;
+}
+
+export async function findCopilotSessionPath(sessionId, options = {}) {
+  const normalizedSessionId = normalizeSessionId(sessionId);
+  if (!normalizedSessionId) {
+    return null;
+  }
+
+  const homeDir = resolveHomeDir(options);
+  const sessionStateDir = options.copilotSessionStateDir || path.join(homeDir, ".copilot", "session-state");
+  const directJsonlPath = path.join(sessionStateDir, `${normalizedSessionId}.jsonl`);
+  if (await pathExists(directJsonlPath, "file")) {
+    return directJsonlPath;
+  }
+
+  const directSessionDir = path.join(sessionStateDir, normalizedSessionId);
+  if (await pathExists(directSessionDir, "directory")) {
+    return directSessionDir;
+  }
+
+  return findPathByName(sessionStateDir, normalizedSessionId);
+}
+
 function resolveHomeDir(options) {
   if (options?.homeDir) {
     return options.homeDir;
@@ -132,6 +199,10 @@ function resolveHomeDir(options) {
   return os.homedir();
 }
 
+function normalizeSessionId(sessionId) {
+  return typeof sessionId === "string" ? sessionId.trim() : "";
+}
+
 function trimHistory(history, limit) {
   const max = Number.isFinite(limit) ? Math.max(1, limit) : DEFAULT_HISTORY_LIMIT;
   if (history.length <= max) {
@@ -473,6 +544,44 @@ async function findJsonlFiles(rootDir) {
   return files;
 }
 
+async function findPathByName(rootDir, sessionId) {
+  const queue = [rootDir];
+  while (queue.length) {
+    const current = queue.pop();
+    let entries = [];
+    try {
+      entries = await fsp.readdir(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const fullPath = path.join(current, entry.name);
+      if (entry.name.includes(sessionId)) {
+        return fullPath;
+      }
+      if (entry.isDirectory()) {
+        queue.push(fullPath);
+      }
+    }
+  }
+  return null;
+}
+
+async function pathExists(targetPath, expectedType) {
+  try {
+    const stats = await fsp.stat(targetPath);
+    if (expectedType === "file") {
+      return stats.isFile();
+    }
+    if (expectedType === "directory") {
+      return stats.isDirectory();
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 async function parseCodexSessionFile(filePath) {
   const fileStream = fs.createReadStream(filePath);
   const rl = readline.createInterface({