@love-moon/conductor-cli 0.1.0

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@love-moon/conductor-cli",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "conductor-cli": "bin/conductor-fire.js",
+    "conductor-fire": "bin/conductor-fire.js",
+    "conductor-daemon": "bin/conductor-daemon.js",
+    "conductor-config": "bin/conductor-config.js"
+  },
+  "files": [
+    "bin",
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "node --test"
+  },
+  "dependencies": {
+    "@conductor/cli2sdk": "0.1.0",
+    "@conductor/sdk": "0.1.0",
+    "@modelcontextprotocol/sdk": "^1.20.2",
+    "@openai/codex-sdk": "^0.58.0",
+    "dotenv": "^16.4.5",
+    "enquirer": "^2.4.1",
+    "js-yaml": "^4.1.1",
+    "ws": "^8.18.0",
+    "yargs": "^17.7.2",
+    "chrome-launcher": "^1.2.1",
+    "chrome-remote-interface": "^0.33.0"
+  }
+}

package/src/daemon.js

@@ -0,0 +1,376 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+import dotenv from "dotenv";
+import yaml from "js-yaml";
+
+import { ConductorWebSocketClient, ConductorConfig, loadConfig, ConfigFileNotFound } from "@conductor/sdk";
+
+dotenv.config();
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const CLI_PATH = path.resolve(__dirname, "..", "bin", "conductor-fire.js");
+
+function log(message) {
+  const ts = new Date().toLocaleString("sv-SE", { timeZone: "Asia/Shanghai" }).replace(" ", "T");
+  process.stdout.write(`[conductor-daemon ${ts}] ${message}\n`);
+}
+
+function logError(message) {
+  const ts = new Date().toLocaleString("sv-SE", { timeZone: "Asia/Shanghai" }).replace(" ", "T");
+  process.stderr.write(`[conductor-daemon ${ts}] ${message}\n`);
+}
+
+function getUserConfig(configFilePath) {
+  try {
+    const home = os.homedir();
+    const configPath = configFilePath || path.join(home, ".conductor", "config.yaml");
+    if (fs.existsSync(configPath)) {
+      const content = fs.readFileSync(configPath, "utf8");
+      const parsed = yaml.load(content);
+      if (parsed && typeof parsed === "object") {
+        return parsed;
+      }
+    }
+  } catch (error) {
+    // ignore error
+  }
+  return {};
+}
+
+export function startDaemon(config = {}, deps = {}) {
+  let fileConfig;
+  try {
+    fileConfig = loadConfig(config.CONFIG_FILE);
+    log(`Loaded config from ${config.CONFIG_FILE || "~/.conductor/config.yaml"}`);
+  } catch (err) {
+    if (!(err instanceof ConfigFileNotFound)) {
+      log(`Failed to load config: ${err.message}`);
+    }
+  }
+
+  const userConfig = getUserConfig(config.CONFIG_FILE);
+  const explicitWsUrl =
+    config.BACKEND_URL ||
+    process.env.CONDUCTOR_BACKEND_WS_URL ||
+    process.env.CONDUCTOR_WS_URL ||
+    null;
+  const derivedHttpFromWs = explicitWsUrl ? deriveBackendHttpFromWebsocket(explicitWsUrl) : null;
+  const BACKEND_HTTP =
+    config.BACKEND_HTTP ||
+    process.env.CONDUCTOR_BACKEND_URL ||
+    derivedHttpFromWs ||
+    fileConfig?.backendUrl ||
+    "http://localhost:6152";
+  const BACKEND_URL =
+    explicitWsUrl ||
+    deriveWebsocketUrlFromHttp(BACKEND_HTTP);
+  const AGENT_TOKEN =
+    config.AGENT_TOKEN || process.env.CONDUCTOR_AGENT_TOKEN || fileConfig?.agentToken || "default-agent-token";
+  const AGENT_NAME = (config.NAME || process.env.CONDUCTOR_DAEMON_NAME || os.hostname()).trim();
+  if (!AGENT_NAME) {
+    logError("Daemon name is required. Set --name or CONDUCTOR_DAEMON_NAME.");
+    process.exit(1);
+  }
+  const WORKSPACE_ROOT =
+    config.WORKSPACE_ROOT ||
+    process.env.CONDUCTOR_WS ||
+    userConfig.workspace ||
+    path.join(process.env.HOME || "/tmp", "ws");
+  const CLI_PATH_VAL = config.CLI_PATH || CLI_PATH;
+
+  const spawnFn = deps.spawn || spawn;
+  const mkdirSyncFn = deps.mkdirSync || fs.mkdirSync;
+  const writeFileSyncFn = deps.writeFileSync || fs.writeFileSync;
+  const existsSyncFn = deps.existsSync || fs.existsSync;
+  const readFileSyncFn = deps.readFileSync || fs.readFileSync;
+  const unlinkSyncFn = deps.unlinkSync || fs.unlinkSync;
+  const createWriteStreamFn = deps.createWriteStream || fs.createWriteStream;
+  const fetchFn = deps.fetch || fetch;
+  const exitFn = deps.exit || process.exit;
+
+  try {
+    mkdirSyncFn(WORKSPACE_ROOT, { recursive: true });
+  } catch (err) {
+    logError(`Failed to create workspace root: ${err}`);
+    process.exit(1);
+  }
+
+  const LOCK_FILE = path.join(WORKSPACE_ROOT, "daemon.pid");
+  try {
+    if (existsSyncFn(LOCK_FILE)) {
+      const pid = parseInt(readFileSyncFn(LOCK_FILE, "utf-8"), 10);
+      if (!Number.isNaN(pid)) {
+        try {
+          process.kill(pid, 0);
+          logError(`Daemon already running with PID ${pid}`);
+          process.exit(1);
+        } catch (e) {
+          if (e.code === "ESRCH") {
+            log("Removing stale lock file");
+            unlinkSyncFn(LOCK_FILE);
+          } else {
+            logError(`Daemon already running with PID ${pid} (access denied)`);
+            process.exit(1);
+          }
+        }
+      }
+    }
+    writeFileSyncFn(LOCK_FILE, process.pid.toString());
+  } catch (err) {
+    logError("Failed to acquire lock:", err);
+    process.exit(1);
+  }
+
+  const cleanupLock = () => {
+    try {
+      if (existsSyncFn(LOCK_FILE)) {
+        const pid = parseInt(readFileSyncFn(LOCK_FILE, "utf-8"), 10);
+        if (pid === process.pid) {
+          unlinkSyncFn(LOCK_FILE);
+        }
+      }
+    } catch (e) {
+      // ignore
+    }
+  };
+
+  process.on("exit", cleanupLock);
+  process.on("SIGINT", () => {
+    cleanupLock();
+    process.exit();
+  });
+  process.on("SIGTERM", () => {
+    cleanupLock();
+    process.exit();
+  });
+  process.on("uncaughtException", (err) => {
+    logError(`Uncaught exception: ${err}`);
+    cleanupLock();
+    process.exit(1);
+  });
+
+  if (config.CLEAN_ALL) {
+    cleanAllAgents(BACKEND_HTTP, AGENT_TOKEN, fetchFn)
+      .then((result) => {
+        log(`Cleaned stale daemons: removed=${result.removed} remaining=${result.remaining}`);
+      })
+      .catch((err) => {
+        log(`Failed to clean daemons: ${err.message}`);
+      })
+      .finally(() => exitFn(0));
+    return { close: () => {} };
+  }
+
+  log("Daemon starting...");
+  log(`Backend: ${BACKEND_URL}`);
+  log(`Workspace: ${WORKSPACE_ROOT}`);
+  log(`CLI Path: ${CLI_PATH_VAL}`);
+  log(`Daemon Name: ${AGENT_NAME}`);
+
+  const sdkConfig = new ConductorConfig({
+    agentToken: AGENT_TOKEN,
+    backendUrl: BACKEND_HTTP,
+    websocketUrl: BACKEND_URL,
+  });
+
+  const client = new ConductorWebSocketClient(sdkConfig, {
+    extraHeaders: {
+      "x-conductor-host": AGENT_NAME,
+    },
+  });
+
+  client.registerHandler((payload) => {
+    handleEvent(payload);
+  });
+
+  client
+    .connect()
+    .then(() => {
+      log("Connected to backend");
+    })
+    .catch((err) => {
+      logError(`Failed to connect: ${err}`);
+    });
+
+  function handleEvent(event) {
+    if (event.type === "create_task") {
+      handleCreateTask(event.payload);
+    }
+  }
+
+  function handleCreateTask(payload) {
+    const { task_id: taskId, project_id: projectId, backend_type: backendType, initial_content: initialContent } =
+      payload || {};
+
+    if (!taskId || !projectId) {
+      logError(`Invalid create_task payload: ${JSON.stringify(payload)}`);
+      return;
+    }
+
+    log("");
+    log(`Creating task ${taskId} for project ${projectId} (${backendType})`);
+    client
+      .sendJson({
+        type: "task_status_update",
+        payload: {
+          task_id: taskId,
+          project_id: projectId,
+          status: "CREATED",
+        },
+      })
+      .catch((err) => {
+        logError(`Failed to report task status (CREATED) for ${taskId}: ${err?.message || err}`);
+      });
+
+    const taskDir = path.join(WORKSPACE_ROOT, projectId, taskId);
+    mkdirSyncFn(taskDir, { recursive: true });
+
+    const args = [];
+    if (backendType) {
+      args.push("--backend", backendType);
+    }
+    if (initialContent) {
+      args.push("--prefill", initialContent);
+    }
+    // Explicitly separate conductor flags from backend args so they don't leak into messages
+    args.push("--");
+
+    const logPath = path.join(taskDir, ".conductor.log");
+    let logStream;
+    try {
+      logStream = createWriteStreamFn(logPath, { flags: "a" });
+    } catch (err) {
+      logError(`Failed to open log file ${logPath}: ${err.message}`);
+    }
+
+    log(`New task workspace: ${taskDir}`);
+    log(`Logs: ${logPath}`);
+
+    const env = {
+      ...process.env,
+      CONDUCTOR_PROJECT_ID: projectId,
+      CONDUCTOR_TASK_ID: taskId,
+    };
+    if (config.CONFIG_FILE) {
+      env.CONDUCTOR_CONFIG = config.CONFIG_FILE;
+    }
+    if (AGENT_TOKEN) {
+      env.CONDUCTOR_AGENT_TOKEN = AGENT_TOKEN;
+    }
+    if (BACKEND_HTTP) {
+      env.CONDUCTOR_BACKEND_URL = BACKEND_HTTP;
+    }
+
+    const child = spawnFn(process.execPath, [CLI_PATH_VAL, ...args], {
+      cwd: taskDir,
+      env,
+      stdio: ["inherit", "pipe", "pipe"],
+    });
+    client
+      .sendJson({
+        type: "task_status_update",
+        payload: {
+          task_id: taskId,
+          project_id: projectId,
+          status: "RUNNING",
+        },
+      })
+      .catch((err) => {
+        logError(`Failed to report task status (RUNNING) for ${taskId}: ${err?.message || err}`);
+      });
+
+    if (child.stdout && typeof child.stdout.pipe === "function" && logStream) {
+      child.stdout.pipe(logStream, { end: false });
+    } else if (child.stdout && typeof child.stdout.on === "function" && logStream) {
+      child.stdout.on("data", (chunk) => logStream.write(chunk));
+    }
+    if (child.stderr && typeof child.stderr.pipe === "function" && logStream) {
+      child.stderr.pipe(logStream, { end: false });
+    } else if (child.stderr && typeof child.stderr.on === "function" && logStream) {
+      child.stderr.on("data", (chunk) => logStream.write(chunk));
+    }
+
+    child.on("error", (err) => {
+      logError(`Failed to spawn CLI: ${err.message}`);
+      if (logStream) {
+        const ts = new Date().toLocaleString("sv-SE", { timeZone: "Asia/Shanghai" }).replace(" ", "T");
+        logStream.write(`[daemon ${ts}] spawn error: ${err.message}\n`);
+      }
+    });
+
+    child.on("exit", (code) => {
+      if (logStream) {
+        const ts = new Date().toLocaleString("sv-SE", { timeZone: "Asia/Shanghai" }).replace(" ", "T");
+        logStream.write(`[daemon ${ts}] process exited with code ${code}\n`);
+        logStream.end();
+      }
+      log(`Task ${taskId} finished with code ${code}`);
+      log(`Logs: ${logPath}`);
+      const status = code === 0 ? "COMPLETED" : "FAILED";
+      client
+        .sendJson({
+          type: "task_status_update",
+          payload: {
+            task_id: taskId,
+            project_id: projectId,
+            status,
+            summary: code === 0 ? "completed" : `exited with code ${code}`,
+          },
+        })
+        .catch((err) => {
+          logError(`Failed to report task status (${status}) for ${taskId}: ${err?.message || err}`);
+        });
+    });
+  }
+
+  return {
+    close: () => {
+      client.disconnect();
+    },
+  };
+}
+
+async function cleanAllAgents(backendUrl, agentToken, fetchImpl) {
+  const fetchFn = fetchImpl || fetch;
+  const target = `${backendUrl.replace(/\/$/, "")}/agents/cleanup`;
+  const headers = {
+    Authorization: `Bearer ${agentToken}`,
+  };
+  const res = await fetch(target, { method: "GET", headers });
+  if (!res.ok) {
+    throw new Error(`cleanup failed: ${res.status} ${res.statusText}`);
+  }
+  return res.json();
+}
+
+function deriveBackendHttpFromWebsocket(wsUrl) {
+  try {
+    const url = new URL(wsUrl);
+    if (url.protocol === "ws:") {
+      url.protocol = "http:";
+    } else if (url.protocol === "wss:") {
+      url.protocol = "https:";
+    }
+    url.pathname = "/";
+    url.search = "";
+    url.hash = "";
+    return `${url.protocol}//${url.host}`;
+  } catch {
+    return null;
+  }
+}
+
+function deriveWebsocketUrlFromHttp(httpUrl) {
+  try {
+    const url = new URL(httpUrl);
+    const scheme = url.protocol === "https:" ? "wss" : "ws";
+    return `${scheme}://${url.host}/ws/agent`;
+  } catch {
+    return "ws://localhost:6152/ws/agent";
+  }
+}