@love-moon/conductor-cli 0.2.20 → 0.2.22

package/bin/conductor-daemon.js

@@ -14,6 +14,56 @@ const argv = hideBin(process.argv);
 
 const CLI_NAME = process.env.CONDUCTOR_CLI_NAME || "conductor-daemon";
 
+function parseJsonArrayEnv(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(value);
+    if (!Array.isArray(parsed)) {
+      return null;
+    }
+    return parsed.filter((entry) => typeof entry === "string");
+  } catch {
+    return null;
+  }
+}
+
+function stripNohupArgs(args) {
+  return args.filter((arg) => !(arg === "--nohup" || arg.startsWith("--nohup=")));
+}
+
+function resolveLauncherConfig() {
+  const inheritedLauncherScript =
+    typeof process.env.CONDUCTOR_LAUNCHER_SCRIPT === "string" &&
+    process.env.CONDUCTOR_LAUNCHER_SCRIPT.trim()
+      ? process.env.CONDUCTOR_LAUNCHER_SCRIPT.trim()
+      : null;
+  const inheritedSubcommand =
+    typeof process.env.CONDUCTOR_SUBCOMMAND === "string" &&
+    process.env.CONDUCTOR_SUBCOMMAND.trim()
+      ? process.env.CONDUCTOR_SUBCOMMAND.trim()
+      : null;
+  const inheritedSubcommandArgs = parseJsonArrayEnv(process.env.CONDUCTOR_SUBCOMMAND_ARGS_JSON);
+
+  if (inheritedLauncherScript && inheritedSubcommand === "daemon" && inheritedSubcommandArgs) {
+    return {
+      restartLauncherScript: inheritedLauncherScript,
+      restartLauncherArgs: ["daemon", ...stripNohupArgs(inheritedSubcommandArgs)],
+      versionCheckScript: inheritedLauncherScript,
+      versionCheckArgs: ["--version"],
+    };
+  }
+
+  const daemonScript = path.resolve(process.argv[1]);
+  return {
+    restartLauncherScript: daemonScript,
+    restartLauncherArgs: argv,
+    versionCheckScript: inheritedLauncherScript,
+    versionCheckArgs: ["--version"],
+  };
+}
+
 function formatBeijingTimestampForFile(date = new Date()) {
   const base = date
     .toLocaleString("sv-SE", { timeZone: "Asia/Shanghai", hour12: false })
@@ -149,4 +199,5 @@ startDaemon({
   CLEAN_ALL: args.cleanAll,
   CONFIG_FILE: args.configFile,
   FORCE: args.force,
+  ...resolveLauncherConfig(),
 });

package/bin/conductor-fire.js

@@ -42,6 +42,12 @@ const CLI_NAME = (process.env.CONDUCTOR_CLI_NAME || path.basename(process.argv[1
   "",
 );
 
+export function buildConductorConnectHeaders(version = pkgJson.version) {
+  return {
+    "x-conductor-version": version,
+  };
+}
+
 // Load allow_cli_list from config file (no defaults - must be configured)
 function loadAllowCliList(configFilePath) {
   try {
@@ -527,6 +533,7 @@ async function main() {
     conductor = await ConductorClient.connect({
       projectPath: runtimeProjectPath,
       extraEnv: env,
+      extraHeaders: buildConductorConnectHeaders(),
       configFile: cliArgs.configFile,
       onConnected: (event) => {
         fireWatchdog.onConnected(event);
@@ -1220,6 +1227,7 @@ export async function applyWorkingDirectory(targetPath) {
   }
   try {
     process.chdir(normalizedPath);
+    process.env.PWD = process.cwd();
   } catch (error) {
     throw new Error(`Cannot switch working directory to ${normalizedPath}: ${error?.message || error}`);
   }

package/bin/conductor-update.js

@@ -8,9 +8,15 @@ 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 { spawn } from "node:child_process";
 import process from "node:process";
 import readline from "node:readline/promises";
+import {
+  PACKAGE_NAME,
+  fetchLatestVersion,
+  isNewerVersion,
+  detectPackageManager,
+} from "../src/version-check.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -18,7 +24,6 @@ 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 颜色代码
@@ -110,75 +115,11 @@ async function main() {
 }
 
 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;
+  const version = await fetchLatestVersion();
+  if (!version) {
+    throw new Error("Could not fetch latest version from npm registry");
   }
-  
-  return false; // 版本相同
+  return version;
 }
 
 async function confirmUpdate(version) {
@@ -201,7 +142,10 @@ async function confirmUpdate(version) {
 async function performUpdate() {
   return new Promise((resolve, reject) => {
     // 检测使用的包管理器
-    const packageManager = detectPackageManager();
+    const packageManager = detectPackageManager({
+      launcherPath: process.env.CONDUCTOR_LAUNCHER_SCRIPT || process.argv[1],
+      packageRoot: PKG_ROOT,
+    });
     console.log(`   Using package manager: ${colorize(packageManager, "cyan")}`);
     console.log("");
     
@@ -245,45 +189,6 @@ async function performUpdate() {
   });
 }
 
-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
 

package/bin/conductor.js

@@ -13,16 +13,13 @@
  *   channel  - Connect user-owned chat channel providers
  */
 
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } 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"; 
+import { maybeCheckForUpdates } from "../src/cli-update-notifier.js";
 
 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"));
@@ -30,57 +27,81 @@ const pkgJson = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, "package.json"),
 // 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);
+export function runConductorCli(args = argv, deps = {}) {
+  const consoleImpl = deps.console || console;
+  const importModule = deps.importModule || ((subcommandPath) => import(subcommandPath));
+  const env = deps.env || process.env;
+  const processArgv = deps.processArgv || process.argv;
+  const fsExistsSync = deps.existsSync || fs.existsSync;
+  const checkForUpdates = deps.maybeCheckForUpdates || maybeCheckForUpdates;
+  const validSubcommands = ["fire", "daemon", "config", "update", "diagnose", "send-file", "channel"];
+
+  if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+    showHelp(consoleImpl);
+    return { shouldExit: true, exitCode: 0 };
+  }
+
+  if (args[0] === "--version" || args[0] === "-v") {
+    const commitId = pkgJson.gitCommitId || "unknown";
+    consoleImpl.log(`conductor version ${pkgJson.version} (${commitId})`);
+    return { shouldExit: true, exitCode: 0 };
+  }
+
+  const subcommand = args[0];
+  if (!validSubcommands.includes(subcommand)) {
+    consoleImpl.error(`Error: Unknown subcommand '${subcommand}'`);
+    consoleImpl.error(`Valid subcommands: ${validSubcommands.join(", ")}`);
+    consoleImpl.error(`Run 'conductor --help' for usage information.`);
+    return { shouldExit: true, exitCode: 1 };
+  }
+
+  void checkForUpdates({
+    currentVersion: pkgJson.version,
+    subcommand,
+    env,
+  }).catch(() => {});
+
+  const subcommandArgs = args.slice(1);
+  env.CONDUCTOR_CLI_NAME = `conductor ${subcommand}`;
+  env.CONDUCTOR_LAUNCHER_SCRIPT = processArgv[1] || "";
+  env.CONDUCTOR_SUBCOMMAND = subcommand;
+  env.CONDUCTOR_SUBCOMMAND_ARGS_JSON = JSON.stringify(subcommandArgs);
+
+  const subcommandPath = path.join(__dirname, `conductor-${subcommand}.js`);
+  if (!fsExistsSync(subcommandPath)) {
+    consoleImpl.error(`Error: Subcommand implementation not found: ${subcommandPath}`);
+    return { shouldExit: true, exitCode: 1 };
+  }
+
+  process.argv = [processArgv[0], subcommandPath, ...subcommandArgs];
+  importModule(subcommandPath).catch((error) => {
+    consoleImpl.error(`Error loading subcommand '${subcommand}': ${error.message}`);
+    process.exit(1);
+  });
+  return { shouldExit: false, exitCode: 0 };
 }
 
-// If version flag, show version
-if (argv[0] === "--version" || argv[0] === "-v") {
-  const commitId = pkgJson.gitCommitId || "unknown";
-  console.log(`conductor version ${pkgJson.version} (${commitId})`);
-  process.exit(0);
+const isDirectExecution = (() => {
+  const entryPath = process.argv[1];
+  if (!entryPath) {
+    return false;
+  }
+  try {
+    return pathToFileURL(entryPath).href === import.meta.url;
+  } catch {
+    return false;
+  }
+})();
+
+if (isDirectExecution) {
+  const result = runConductorCli();
+  if (result.shouldExit) {
+    process.exit(result.exitCode);
+  }
 }
 
-// Get the subcommand
-const subcommand = argv[0];
-
-// Valid subcommands
-const validSubcommands = ["fire", "daemon", "config", "update", "diagnose", "send-file", "channel"];
-
-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
+function showHelp(consoleImpl = console) {
+  consoleImpl.log(`conductor - Conductor CLI tool
 
 Usage: conductor <subcommand> [options]
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.2.20",
-  "gitCommitId": "d622756",
+  "version": "0.2.22",
+  "gitCommitId": "d04b18c",
   "type": "module",
   "bin": {
     "conductor": "bin/conductor.js"
@@ -17,8 +17,8 @@
     "test": "node --test test/*.test.js"
   },
   "dependencies": {
-    "@love-moon/ai-sdk": "0.2.20",
-    "@love-moon/conductor-sdk": "0.2.20",
+    "@love-moon/ai-sdk": "0.2.22",
+    "@love-moon/conductor-sdk": "0.2.22",
     "dotenv": "^16.4.5",
     "enquirer": "^2.4.1",
     "js-yaml": "^4.1.1",

package/src/cli-update-notifier.js

@@ -0,0 +1,241 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+import { fetchLatestVersion, isNewerVersion } from "./version-check.js";
+
+export const DEFAULT_VERSION_CHECK_INTERVAL_MS = 12 * 60 * 60 * 1000;
+export const DEFAULT_VERSION_NOTIFY_INTERVAL_MS = 24 * 60 * 60 * 1000;
+export const DEFAULT_VERSION_CHECK_TIMEOUT_MS = 800;
+const DEFAULT_CACHE_FILE = "version-check.json";
+
+function normalizeOptionalString(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const normalized = value.trim();
+  return normalized || null;
+}
+
+function parseBooleanLike(value) {
+  if (typeof value !== "string") {
+    return false;
+  }
+  return ["1", "true", "yes", "on"].includes(value.trim().toLowerCase());
+}
+
+function parseTimestamp(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    return null;
+  }
+  const parsed = Date.parse(value);
+  if (Number.isNaN(parsed)) {
+    return null;
+  }
+  return new Date(parsed).toISOString();
+}
+
+function isTimestampOlderThan(value, ageMs, nowMs) {
+  const parsed = value ? Date.parse(value) : NaN;
+  if (Number.isNaN(parsed)) {
+    return true;
+  }
+  return nowMs - parsed >= ageMs;
+}
+
+export function resolveVersionCheckCachePath(options = {}) {
+  const homeDir = options.homeDir || process.env.HOME || os.homedir() || "/tmp";
+  return path.join(homeDir, ".conductor", DEFAULT_CACHE_FILE);
+}
+
+export function normalizeVersionCheckCache(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  const latestVersion = normalizeOptionalString(value.latestVersion);
+  const lastNotifiedVersion = normalizeOptionalString(value.lastNotifiedVersion);
+  const normalized = {
+    lastCheckedAt: parseTimestamp(value.lastCheckedAt),
+    latestVersion,
+    latestCheckedAt: parseTimestamp(value.latestCheckedAt),
+    lastNotifiedVersion,
+    lastNotifiedAt: parseTimestamp(value.lastNotifiedAt),
+  };
+  if (
+    !normalized.lastCheckedAt &&
+    !normalized.latestVersion &&
+    !normalized.latestCheckedAt &&
+    !normalized.lastNotifiedVersion &&
+    !normalized.lastNotifiedAt
+  ) {
+    return null;
+  }
+  return normalized;
+}
+
+export async function readVersionCheckCache(options = {}) {
+  const readFileFn = options.readFile || fs.readFile;
+  const cachePath = options.cachePath || resolveVersionCheckCachePath(options);
+  try {
+    const content = await readFileFn(cachePath, "utf8");
+    return normalizeVersionCheckCache(JSON.parse(content));
+  } catch {
+    return null;
+  }
+}
+
+export async function writeVersionCheckCache(cache, options = {}) {
+  const writeFileFn = options.writeFile || fs.writeFile;
+  const mkdirFn = options.mkdir || fs.mkdir;
+  const cachePath = options.cachePath || resolveVersionCheckCachePath(options);
+  await mkdirFn(path.dirname(cachePath), { recursive: true });
+  await writeFileFn(cachePath, JSON.stringify(cache, null, 2), "utf8");
+}
+
+export function shouldSkipVersionCheck(options = {}) {
+  const env = options.env || process.env;
+  const subcommand = normalizeOptionalString(options.subcommand);
+  const stdoutIsTTY = options.stdoutIsTTY ?? Boolean(process.stdout?.isTTY);
+
+  if (parseBooleanLike(env.CONDUCTOR_SKIP_UPDATE_CHECK)) {
+    return { skip: true, reason: "disabled_by_env" };
+  }
+  if (subcommand === "update") {
+    return { skip: true, reason: "update_subcommand" };
+  }
+  if (!stdoutIsTTY) {
+    return { skip: true, reason: "non_tty" };
+  }
+  if (parseBooleanLike(env.CI)) {
+    return { skip: true, reason: "ci" };
+  }
+  if (normalizeOptionalString(env.CONDUCTOR_CLI_COMMAND)) {
+    return { skip: true, reason: "nested_cli" };
+  }
+  return { skip: false, reason: null };
+}
+
+export function buildUpdateNotice({ currentVersion, latestVersion }) {
+  return `New conductor version available: ${currentVersion} -> ${latestVersion}. Run: conductor update`;
+}
+
+function shouldNotifyVersion({ latestVersion, currentVersion, cache, nowMs, notifyIntervalMs }) {
+  if (!latestVersion || !isNewerVersion(latestVersion, currentVersion)) {
+    return false;
+  }
+  if (!cache?.lastNotifiedVersion || cache.lastNotifiedVersion !== latestVersion) {
+    return true;
+  }
+  return isTimestampOlderThan(cache.lastNotifiedAt, notifyIntervalMs, nowMs);
+}
+
+function shouldRefreshVersion({ cache, nowMs, checkIntervalMs }) {
+  if (!cache?.lastCheckedAt) {
+    return true;
+  }
+  return isTimestampOlderThan(cache.lastCheckedAt, checkIntervalMs, nowMs);
+}
+
+function createUpdatedCache(previousCache, updates = {}) {
+  return normalizeVersionCheckCache({
+    ...previousCache,
+    ...updates,
+  });
+}
+
+export async function maybeCheckForUpdates(options = {}) {
+  const env = options.env || process.env;
+  const currentVersion = normalizeOptionalString(options.currentVersion);
+  const subcommand = normalizeOptionalString(options.subcommand);
+  const nowMs = options.nowMs ?? Date.now();
+  const checkIntervalMs = options.checkIntervalMs ?? DEFAULT_VERSION_CHECK_INTERVAL_MS;
+  const notifyIntervalMs = options.notifyIntervalMs ?? DEFAULT_VERSION_NOTIFY_INTERVAL_MS;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_VERSION_CHECK_TIMEOUT_MS;
+  const skip = shouldSkipVersionCheck({
+    env,
+    subcommand,
+    stdoutIsTTY: options.stdoutIsTTY,
+  });
+
+  if (skip.skip || !currentVersion) {
+    return { skipped: true, reason: skip.reason || "missing_current_version" };
+  }
+
+  const writeNotice = options.writeNotice || ((message) => process.stderr.write(`${message}\n`));
+  const fetchLatestVersionFn = options.fetchLatestVersion || fetchLatestVersion;
+  const cacheOptions = {
+    cachePath: options.cachePath,
+    homeDir: options.homeDir || env.HOME,
+    readFile: options.readFile,
+    writeFile: options.writeFile,
+    mkdir: options.mkdir,
+  };
+
+  let cache = await readVersionCheckCache(cacheOptions);
+  const needsRefresh = shouldRefreshVersion({ cache, nowMs, checkIntervalMs });
+
+  if (!needsRefresh) {
+    if (cache?.latestVersion && shouldNotifyVersion({
+      latestVersion: cache.latestVersion,
+      currentVersion,
+      cache,
+      nowMs,
+      notifyIntervalMs,
+    })) {
+      writeNotice(buildUpdateNotice({ currentVersion, latestVersion: cache.latestVersion }));
+      cache = createUpdatedCache(cache, {
+        lastNotifiedVersion: cache.latestVersion,
+        lastNotifiedAt: new Date(nowMs).toISOString(),
+      });
+      if (cache) {
+        await writeVersionCheckCache(cache, cacheOptions);
+      }
+    }
+    return { skipped: false, refreshed: false, latestVersion: cache?.latestVersion || null };
+  }
+
+  let latestVersion = null;
+  try {
+    latestVersion = await fetchLatestVersionFn(undefined, { timeoutMs });
+  } catch {
+    latestVersion = null;
+  }
+
+  cache = createUpdatedCache(cache, {
+    lastCheckedAt: new Date(nowMs).toISOString(),
+    ...(latestVersion
+      ? {
+          latestVersion,
+          latestCheckedAt: new Date(nowMs).toISOString(),
+        }
+      : {}),
+  });
+
+  if (cache) {
+    await writeVersionCheckCache(cache, cacheOptions);
+  }
+
+  const versionToNotify = latestVersion || cache?.latestVersion || null;
+  if (versionToNotify && shouldNotifyVersion({
+    latestVersion: versionToNotify,
+    currentVersion,
+    cache,
+    nowMs,
+    notifyIntervalMs,
+  })) {
+    writeNotice(buildUpdateNotice({ currentVersion, latestVersion: versionToNotify }));
+    cache = createUpdatedCache(cache, {
+      lastNotifiedVersion: versionToNotify,
+      lastNotifiedAt: new Date(nowMs).toISOString(),
+    });
+    if (cache) {
+      await writeVersionCheckCache(cache, cacheOptions);
+    }
+  }
+
+  return {
+    skipped: false,
+    refreshed: true,
+    latestVersion,
+  };
+}