@love-moon/conductor-cli 0.2.19 → 0.2.21

package/bin/conductor-channel.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+import yargs from "yargs/yargs";
+import { hideBin } from "yargs/helpers";
+import { loadConfig } from "@love-moon/conductor-sdk";
+
+const isMainModule = (() => {
+  const currentFile = fileURLToPath(import.meta.url);
+  const entryFile = process.argv[1] ? path.resolve(process.argv[1]) : "";
+  return entryFile === currentFile;
+})();
+
+function resolveDefaultConfigPath(env = process.env) {
+  const home = env.HOME || env.USERPROFILE || os.homedir();
+  return path.join(home, ".conductor", "config.yaml");
+}
+
+function readTextFile(filePath) {
+  return fs.readFileSync(filePath, "utf8");
+}
+
+function ensureFeishuChannelConfig(config) {
+  const feishu = config?.channels?.feishu;
+  if (!feishu?.appId || !feishu?.appSecret || !feishu?.verificationToken) {
+    throw new Error("config.yaml is missing channels.feishu.app_id/app_secret/verification_token");
+  }
+  return feishu;
+}
+
+function formatErrorBody(text) {
+  const normalized = typeof text === "string" ? text.trim() : "";
+  if (!normalized) return "";
+  try {
+    const parsed = JSON.parse(normalized);
+    if (parsed && typeof parsed === "object" && typeof parsed.error === "string") {
+      return parsed.error;
+    }
+  } catch {
+    // ignore
+  }
+  return normalized;
+}
+
+export async function connectFeishuChannel(options = {}) {
+  const env = options.env ?? process.env;
+  const fetchImpl = options.fetchImpl ?? global.fetch;
+  if (typeof fetchImpl !== "function") {
+    throw new Error("fetch is not available");
+  }
+
+  const resolvedConfigPath = path.resolve(options.configFile || resolveDefaultConfigPath(env));
+  const rawYaml = readTextFile(resolvedConfigPath);
+  const config = loadConfig(resolvedConfigPath, { env });
+  const feishu = ensureFeishuChannelConfig(config);
+
+  const url = new URL("/api/channel/feishu/config", config.backendUrl);
+  const response = await fetchImpl(String(url), {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${config.agentToken}`,
+      "Content-Type": "application/json",
+      Accept: "application/json",
+    },
+    body: JSON.stringify({ yaml: rawYaml }),
+  });
+
+  const rawText = await response.text();
+  if (!response.ok) {
+    const detail = formatErrorBody(rawText);
+    throw new Error(`Failed to connect Feishu channel (${response.status})${detail ? `: ${detail}` : ""}`);
+  }
+
+  const parsed = rawText ? JSON.parse(rawText) : {};
+  return {
+    configPath: resolvedConfigPath,
+    feishu,
+    config: parsed.config ?? null,
+  };
+}
+
+export async function main(argvInput = hideBin(process.argv), dependencies = {}) {
+  const log = dependencies.log ?? console.log;
+  const logError = dependencies.logError ?? console.error;
+
+  await yargs(argvInput)
+    .scriptName("conductor channel")
+    .command(
+      "connect feishu",
+      "Upload channels.feishu from config.yaml to Conductor backend",
+      (command) => command.option("config-file", {
+        type: "string",
+        describe: "Path to Conductor config file",
+      }),
+      async (argv) => {
+        try {
+          const result = await connectFeishuChannel({
+            configFile: argv.configFile,
+          });
+          const effective = result.config ?? {
+            provider: "FEISHU",
+            appId: result.feishu.appId,
+            verificationToken: result.feishu.verificationToken,
+          };
+          log(`Connected Feishu channel from ${result.configPath}`);
+          log(`app_id: ${effective.appId}`);
+          log(`verification_token: ${effective.verificationToken}`);
+          log("Configure the same verification_token in Feishu Open Platform webhook settings.");
+        } catch (error) {
+          logError(error instanceof Error ? error.message : String(error));
+          process.exitCode = 1;
+        }
+      },
+    )
+    .demandCommand(1)
+    .help()
+    .parseAsync();
+}
+
+if (isMainModule) {
+  main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  });
+}

package/bin/conductor-config.js

@@ -23,7 +23,7 @@ const DEFAULT_CLIs = {
   },
   codex: {
     command: "codex",
-    execArgs: "exec --dangerously-bypass-approvals-and-sandbox --skip-git-repo-check",
+    execArgs: "--dangerously-bypass-approvals-and-sandbox --ask-for-approval never",
     description: "OpenAI Codex CLI"
   },
   // gemini: {

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-diagnose.js

@@ -244,6 +244,7 @@ function printReport(taskId, report) {
   const diagnosis = payload?.diagnosis || {};
   const task = payload?.task || {};
   const realtime = payload?.realtime || {};
+  const ptyTransport = payload?.pty_transport || payload?.ptyTransport || {};
   const messages = payload?.messages || {};
 
   process.stdout.write(`Task: ${task?.id || taskId}\n`);
@@ -273,6 +274,25 @@ function printReport(taskId, report) {
       );
     }
   }
+  const latestLatency = ptyTransport?.latest_latency_sample || ptyTransport?.latestLatencySample;
+  if (latestLatency) {
+    process.stdout.write(
+      `- pty.latest_latency: client->server=${formatLatencyMs(
+        latestLatency.client_input_to_server_received_ms ?? latestLatency.clientInputToServerReceivedMs,
+      )}, server->daemon=${formatLatencyMs(
+        latestLatency.server_received_to_daemon_received_ms ?? latestLatency.serverReceivedToDaemonReceivedMs,
+      )}, daemon->first_output=${formatLatencyMs(
+        latestLatency.daemon_input_to_first_output_ms ?? latestLatency.daemonInputToFirstOutputMs,
+      )}, client->first_output=${formatLatencyMs(
+        latestLatency.client_input_to_first_output_ms ?? latestLatency.clientInputToFirstOutputMs,
+      )}\n`,
+    );
+    process.stdout.write(
+      `- pty.primary_bottleneck: ${String(
+        ptyTransport?.primary_bottleneck || ptyTransport?.primaryBottleneck || "unknown",
+      )}\n`,
+    );
+  }
 
   const reasons = Array.isArray(diagnosis.reasons) ? diagnosis.reasons : [];
   if (reasons.length > 0) {
@@ -364,6 +384,11 @@ function detectExecutionFailureLoopKey(value) {
   return null;
 }
 
+function formatLatencyMs(value) {
+  const num = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(num) && num >= 0 ? `${Math.round(num)}ms` : "n/a";
+}
+
 function normalizePositiveInt(value, fallback) {
   const parsed = Number.parseInt(String(value ?? ""), 10);
   return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;

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 {
@@ -98,6 +104,30 @@ const DEFAULT_ERROR_LOOP_BACKOFF_MS = 3 * 60 * 1000;
 const DEFAULT_ERROR_LOOP_THRESHOLD = 3;
 const SESSION_BOOTSTRAP_LOCK_TIMEOUT_MS = 15_000;
 const SESSION_BOOTSTRAP_LOCK_RETRY_MS = 50;
+const FIRE_WATCHDOG_INTERVAL_MS = getBoundedEnvInt(
+  "CONDUCTOR_FIRE_WATCHDOG_INTERVAL_MS",
+  10_000,
+  1_000,
+  60_000,
+);
+const FIRE_WATCHDOG_STALE_WS_MS = getBoundedEnvInt(
+  "CONDUCTOR_FIRE_WATCHDOG_STALE_WS_MS",
+  45_000,
+  5_000,
+  5 * 60_000,
+);
+const FIRE_WATCHDOG_CONNECT_GRACE_MS = getBoundedEnvInt(
+  "CONDUCTOR_FIRE_WATCHDOG_CONNECT_GRACE_MS",
+  15_000,
+  1_000,
+  60_000,
+);
+const FIRE_WATCHDOG_RECONNECT_COOLDOWN_MS = getBoundedEnvInt(
+  "CONDUCTOR_FIRE_WATCHDOG_RECONNECT_COOLDOWN_MS",
+  15_000,
+  1_000,
+  2 * 60_000,
+);
 
 function sleepSync(ms) {
   if (!Number.isFinite(ms) || ms <= 0) {
@@ -191,6 +221,176 @@ function appendFireLocalLog(line) {
   }
 }
 
+function formatFireDisconnectDiagnostics(event = {}) {
+  const parts = [];
+  if (event.reason) {
+    parts.push(`reason=${event.reason}`);
+  }
+  if (typeof event.closeCode === "number") {
+    parts.push(`close_code=${event.closeCode}`);
+  }
+  if (event.closeReason) {
+    parts.push(`close_reason=${sanitizeForLog(event.closeReason, 120)}`);
+  }
+  if (event.socketError) {
+    parts.push(`socket_error=${sanitizeForLog(event.socketError, 120)}`);
+  }
+  if (typeof event.missedPongs === "number" && event.missedPongs > 0) {
+    parts.push(`missed_pongs=${event.missedPongs}`);
+  }
+  return parts.join(" ") || "reason=connection_lost";
+}
+
+function formatIsoTimestamp(value) {
+  if (!Number.isFinite(value) || value <= 0) {
+    return "n/a";
+  }
+  return new Date(value).toISOString();
+}
+
+function formatFireWatchdogState({ connectedAt, lastPongAt, lastInboundAt }) {
+  return [
+    `connected_at=${formatIsoTimestamp(connectedAt)}`,
+    `last_pong_at=${formatIsoTimestamp(lastPongAt)}`,
+    `last_inbound_at=${formatIsoTimestamp(lastInboundAt)}`,
+  ].join(" ");
+}
+
+export class FireWatchdog {
+  constructor({
+    intervalMs = FIRE_WATCHDOG_INTERVAL_MS,
+    staleWsMs = FIRE_WATCHDOG_STALE_WS_MS,
+    connectGraceMs = FIRE_WATCHDOG_CONNECT_GRACE_MS,
+    reconnectCooldownMs = FIRE_WATCHDOG_RECONNECT_COOLDOWN_MS,
+    onForceReconnect,
+    logger = () => {},
+    now = () => Date.now(),
+  } = {}) {
+    this.intervalMs = intervalMs;
+    this.staleWsMs = staleWsMs;
+    this.connectGraceMs = connectGraceMs;
+    this.reconnectCooldownMs = reconnectCooldownMs;
+    this.onForceReconnect = onForceReconnect;
+    this.logger = logger;
+    this.now = now;
+    this.wsConnected = false;
+    this.lastConnectedAt = null;
+    this.lastPongAt = null;
+    this.lastInboundAt = null;
+    this.lastHealAt = 0;
+    this.healAttempts = 0;
+    this.awaitingHealthySignalAt = null;
+    this.timer = null;
+  }
+
+  start() {
+    if (this.timer) {
+      return;
+    }
+    this.timer = setInterval(() => {
+      void this.runOnce();
+    }, this.intervalMs);
+    if (typeof this.timer.unref === "function") {
+      this.timer.unref();
+    }
+  }
+
+  stop() {
+    if (!this.timer) {
+      return;
+    }
+    clearInterval(this.timer);
+    this.timer = null;
+  }
+
+  onConnected({ isReconnect = false, connectedAt = this.now() } = {}) {
+    this.wsConnected = true;
+    this.lastConnectedAt = connectedAt;
+    this.lastPongAt =
+      Number.isFinite(this.lastPongAt) && this.lastPongAt > connectedAt ? this.lastPongAt : connectedAt;
+    if (isReconnect && this.healAttempts > 0) {
+      this.awaitingHealthySignalAt = connectedAt;
+    } else if (!isReconnect) {
+      this.awaitingHealthySignalAt = null;
+    }
+  }
+
+  onDisconnected() {
+    this.wsConnected = false;
+  }
+
+  onPong({ at = this.now() } = {}) {
+    this.lastPongAt = at;
+    this.markHealthy("pong", at);
+  }
+
+  onInbound(at = this.now()) {
+    this.lastInboundAt = at;
+    this.markHealthy("inbound", at);
+  }
+
+  markHealthy(signal, at = this.now()) {
+    if (!this.awaitingHealthySignalAt || this.healAttempts === 0) {
+      return;
+    }
+    if (at < this.awaitingHealthySignalAt) {
+      return;
+    }
+    this.logger(
+      `[watchdog] Backend websocket healthy again after self-heal via ${signal} (${formatFireWatchdogState({
+        connectedAt: this.lastConnectedAt,
+        lastPongAt: this.lastPongAt,
+        lastInboundAt: this.lastInboundAt,
+      })})`,
+    );
+    this.awaitingHealthySignalAt = null;
+    this.healAttempts = 0;
+  }
+
+  async runOnce() {
+    if (!this.wsConnected || typeof this.onForceReconnect !== "function") {
+      return false;
+    }
+    const now = this.now();
+    if (!Number.isFinite(this.lastConnectedAt) || now - this.lastConnectedAt < this.connectGraceMs) {
+      return false;
+    }
+    const lastWsHealthAt = Math.max(this.lastPongAt || 0, this.lastInboundAt || 0, this.lastConnectedAt || 0);
+    if (lastWsHealthAt && now - lastWsHealthAt <= this.staleWsMs) {
+      return false;
+    }
+    if (this.lastHealAt && now - this.lastHealAt < this.reconnectCooldownMs) {
+      return false;
+    }
+
+    this.lastHealAt = now;
+    this.healAttempts += 1;
+    this.awaitingHealthySignalAt = null;
+    this.wsConnected = false;
+    this.logger(
+      `[watchdog] stale_ws_health; restarting fire websocket (${this.healAttempts}) (${formatFireWatchdogState({
+        connectedAt: this.lastConnectedAt,
+        lastPongAt: this.lastPongAt,
+        lastInboundAt: this.lastInboundAt,
+      })})`,
+    );
+    await this.onForceReconnect("watchdog:stale_ws_health");
+    return true;
+  }
+
+  getDebugState() {
+    return {
+      wsConnected: this.wsConnected,
+      lastConnectedAt: this.lastConnectedAt,
+      lastPongAt: this.lastPongAt,
+      lastInboundAt: this.lastInboundAt,
+      lastHealAt: this.lastHealAt,
+      healAttempts: this.healAttempts,
+      awaitingHealthySignalAt: this.awaitingHealthySignalAt,
+    };
+  }
+}
+
 async function main() {
   const cliArgs = parseCliArgs();
   let runtimeProjectPath = process.cwd();
@@ -239,6 +439,17 @@ async function main() {
   let pendingRemoteStopEvent = null;
   let conductor = null;
   let reconnectResumeInFlight = false;
+  let fireShuttingDown = false;
+  const fireWatchdog = new FireWatchdog({
+    onForceReconnect: async (reason) => {
+      if (!conductor || typeof conductor.forceReconnect !== "function") {
+        return;
+      }
+      await conductor.forceReconnect(reason);
+    },
+    logger: log,
+  });
+  fireWatchdog.start();
 
   const scheduleReconnectRecovery = ({ isReconnect }) => {
     if (!isReconnect) {
@@ -274,6 +485,7 @@ async function main() {
   };
 
   const handleStopTaskCommand = async (event) => {
+    fireWatchdog.onInbound();
     if (!event || typeof event !== "object") {
       return;
     }
@@ -321,8 +533,21 @@ async function main() {
     conductor = await ConductorClient.connect({
       projectPath: runtimeProjectPath,
       extraEnv: env,
+      extraHeaders: buildConductorConnectHeaders(),
       configFile: cliArgs.configFile,
-      onConnected: scheduleReconnectRecovery,
+      onConnected: (event) => {
+        fireWatchdog.onConnected(event);
+        scheduleReconnectRecovery(event);
+      },
+      onDisconnected: (event) => {
+        fireWatchdog.onDisconnected();
+        if (!fireShuttingDown) {
+          log(`[fire-ws] Disconnected from backend: ${formatFireDisconnectDiagnostics(event)}`);
+        }
+      },
+      onPong: (event) => {
+        fireWatchdog.onPong(event);
+      },
       onStopTask: handleStopTaskCommand,
     });
 
@@ -425,11 +650,13 @@ async function main() {
     };
     const onSigint = () => {
       shutdownSignal = shutdownSignal || "SIGINT";
+      fireShuttingDown = true;
       signals.abort();
       requestBackendShutdown("SIGINT");
     };
     const onSigterm = () => {
       shutdownSignal = shutdownSignal || "SIGTERM";
+      fireShuttingDown = true;
       signals.abort();
       requestBackendShutdown("SIGTERM");
     };
@@ -494,6 +721,8 @@ async function main() {
       }
     }
   } finally {
+    fireShuttingDown = true;
+    fireWatchdog.stop();
     if (backendSession && typeof backendSession.close === "function") {
       try {
         await backendSession.close();

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