@love-moon/conductor-cli 0.2.19 → 0.2.21

package/bin/conductor.js

@@ -10,18 +10,16 @@
  *   update   - Update the CLI to the latest version
  *   diagnose - Diagnose a task in production/backend
  *   send-file - Upload a local file into a task session
+ *   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"));
@@ -29,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"];
-
-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]
 
@@ -90,6 +112,7 @@ Subcommands:
   update    Update the CLI to the latest version
   diagnose  Diagnose a task and print likely root cause
   send-file Upload a local file into a task session
+  channel   Connect user-owned chat channel providers
 
 Options:
   -h, --help     Show this help message
@@ -101,6 +124,7 @@ Examples:
   conductor daemon --config-file ~/.conductor/config.yaml
   conductor diagnose <task-id>
   conductor send-file ./screenshot.png
+  conductor channel connect feishu
   conductor config
   conductor update
 
@@ -111,6 +135,7 @@ For subcommand-specific help:
   conductor update --help
   conductor diagnose --help
   conductor send-file --help
+  conductor channel --help
 
 Version: ${pkgJson.version}
 `);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.2.19",
-  "gitCommitId": "346e048",
+  "version": "0.2.21",
+  "gitCommitId": "fa11085",
   "type": "module",
   "bin": {
     "conductor": "bin/conductor.js"
@@ -17,8 +17,8 @@
     "test": "node --test test/*.test.js"
   },
   "dependencies": {
-    "@love-moon/ai-sdk": "0.2.19",
-    "@love-moon/conductor-sdk": "0.2.19",
+    "@love-moon/ai-sdk": "0.2.21",
+    "@love-moon/conductor-sdk": "0.2.21",
     "dotenv": "^16.4.5",
     "enquirer": "^2.4.1",
     "js-yaml": "^4.1.1",
@@ -28,7 +28,14 @@
     "chrome-launcher": "^1.2.1",
     "chrome-remote-interface": "^0.33.0"
   },
+  "optionalDependencies": {
+    "@roamhq/wrtc": "^0.10.0"
+  },
   "pnpm": {
+    "onlyBuiltDependencies": [
+      "node-pty",
+      "@roamhq/wrtc"
+    ],
     "overrides": {
       "@love-moon/ai-sdk": "file:../modules/ai-sdk",
       "@love-moon/conductor-sdk": "file:../modules/conductor-sdk"

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,
+  };
+}