@love-moon/conductor-cli 0.2.5 → 0.2.7

package/bin/conductor-fire.js

@@ -4,24 +4,21 @@
  * conductor-fire - Conductor-aware AI coding agent runner.
  *
  * Supports configurable backends via allow_cli_list in config file.
- * This CLI bridges various AI coding agents with Conductor via MCP.
+ * This CLI bridges various AI coding agents with Conductor via the Conductor SDK.
  */
 
 import fs from "node:fs";
-import { createRequire } from "node:module";
 import os from "node:os";
 import path from "node:path";
 import process from "node:process";
 import { setTimeout as delay } from "node:timers/promises";
 import { fileURLToPath } from "node:url";
 
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import yargs from "yargs/yargs";
 import { hideBin } from "yargs/helpers";
 import yaml from "js-yaml";
-import { TuiDriver, claudeCodeProfile, codexProfile } from "@love-moon/tui-driver";
-import { loadConfig } from "@love-moon/conductor-sdk";
+import { TuiDriver, claudeCodeProfile, codexProfile, copilotProfile } from "@love-moon/tui-driver";
+import { ConductorClient, loadConfig } from "@love-moon/conductor-sdk";
 import {
   loadHistoryFromSpec,
   parseFromSpec,
@@ -31,21 +28,8 @@ import {
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-const require = createRequire(import.meta.url);
 const PKG_ROOT = path.join(__dirname, "..");
 const CLI_PROJECT_PATH = process.cwd();
-const REPO_ROOT_FALLBACK = path.resolve(__dirname, "..", "..");
-const SDK_FALLBACK_PATH = path.join(REPO_ROOT_FALLBACK, "modules", "sdk");
-const SDK_ROOT =
-  process.env.CONDUCTOR_SDK_PATH ||
-  (() => {
-    try {
-      return path.dirname(require.resolve("@love-moon/conductor-sdk/package.json"));
-    } catch {
-      return SDK_FALLBACK_PATH;
-    }
-  })();
-const MCP_SERVER_SCRIPT = path.join(SDK_ROOT, "dist", "bin", "mcp-server.js");
 
 const pkgJson = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, "package.json"), "utf-8"));
 const CLI_NAME = (process.env.CONDUCTOR_CLI_NAME || path.basename(process.argv[1] || "conductor-fire")).replace(
@@ -122,12 +106,6 @@ const DEFAULT_POLL_INTERVAL_MS = parseInt(
   10,
 );
 
-const MCP_SERVER_LAUNCH = {
-  command: "node",
-  args: [MCP_SERVER_SCRIPT],
-  cwd: SDK_ROOT,
-};
-
 async function main() {
   const cliArgs = parseCliArgs();
 
@@ -145,7 +123,7 @@ async function main() {
 
   if (cliArgs.listBackends) {
     if (supportedBackends.length === 0) {
-      process.stdout.write(`No backends configured.\n\nAdd allow_cli_list to your config file (~/.conductor/config.yaml):\n  allow_cli_list:\n    codex: codex --dangerously-bypass-approvals-and-sandbox\n    claude: claude --dangerously-skip-permissions\n    kimi: kimi\n`);
+      process.stdout.write(`No backends configured.\n\nAdd allow_cli_list to your config file (~/.conductor/config.yaml):\n  allow_cli_list:\n    codex: codex --dangerously-bypass-approvals-and-sandbox\n    claude: claude --dangerously-skip-permissions\n    copilot: copilot --allow-all-paths --allow-all-tools\n    kimi: kimi\n`);
     } else {
       process.stdout.write(`Supported backends (from config):\n`);
       for (const [name, command] of Object.entries(allowCliList)) {
@@ -223,10 +201,9 @@ async function main() {
   }
 
   const conductor = await ConductorClient.connect({
-    launcher: MCP_SERVER_LAUNCH,
-    workingDirectory: CLI_PROJECT_PATH,
     projectPath: CLI_PROJECT_PATH,
     extraEnv: env,
+    configFile: cliArgs.configFile,
   });
 
   const taskContext = await ensureTaskContext(conductor, {
@@ -268,19 +245,44 @@ async function main() {
   process.on("SIGINT", onSigint);
   process.on("SIGTERM", onSigterm);
 
+  if (!launchedByDaemon) {
+    try {
+      await conductor.sendTaskStatus(taskContext.taskId, {
+        status: "RUNNING",
+      });
+    } catch (error) {
+      log(`Failed to report task status (RUNNING): ${error?.message || error}`);
+    }
+  }
+
+  let runnerError = null;
   try {
     await runner.start(signals.signal);
+  } catch (error) {
+    runnerError = error;
+    throw error;
   } finally {
     process.off("SIGINT", onSigint);
     process.off("SIGTERM", onSigterm);
-    if (shutdownSignal && !launchedByDaemon) {
+    if (!launchedByDaemon) {
+      const finalStatus = shutdownSignal
+        ? {
+            status: "KILLED",
+            summary: `terminated by ${shutdownSignal}`,
+          }
+        : runnerError
+          ? {
+              status: "KILLED",
+              summary: `conductor fire failed: ${runnerError?.message || runnerError}`,
+            }
+          : {
+              status: "COMPLETED",
+              summary: "conductor fire exited",
+            };
       try {
-        await conductor.sendTaskStatus(taskContext.taskId, {
-          status: "KILLED",
-          summary: `terminated by ${shutdownSignal}`,
-        });
+        await conductor.sendTaskStatus(taskContext.taskId, finalStatus);
       } catch (error) {
-        log(`Failed to report task status (KILLED): ${error?.message || error}`);
+        log(`Failed to report task status (${finalStatus.status}): ${error?.message || error}`);
       }
     }
     if (typeof backendSession.close === "function") {
@@ -403,10 +405,12 @@ Config file format (~/.conductor/config.yaml):
   allow_cli_list:
     codex: codex --dangerously-bypass-approvals-and-sandbox
     claude: claude --dangerously-skip-permissions
+    copilot: copilot --allow-all-paths --allow-all-tools
 
 Examples:
   ${CLI_NAME} -- "fix the bug"                    # Use default backend
   ${CLI_NAME} --backend claude -- "fix the bug"   # Use Claude CLI backend
+  ${CLI_NAME} --backend copilot -- "fix the bug"  # Use GitHub Copilot CLI backend
   ${CLI_NAME} --list-backends                     # Show configured backends
   ${CLI_NAME} --config-file ~/.conductor/config.yaml -- "fix the bug"
 
@@ -535,7 +539,19 @@ async function resolveProjectId(conductor, explicit) {
   try {
     const record = await conductor.getLocalProjectRecord();
     if (record?.project_id) {
-      return record.project_id;
+      try {
+        const listing = await conductor.listProjects();
+        const exists = Array.isArray(listing?.projects)
+          ? listing.projects.some((project) => String(project?.id || "") === String(record.project_id))
+          : false;
+        if (exists) {
+          return record.project_id;
+        }
+        log(`Local session project ${record.project_id} no longer exists; falling back to server project list`);
+      } catch (verifyError) {
+        log(`Unable to verify local project record; using cached project id: ${verifyError.message}`);
+        return record.project_id;
+      }
     }
   } catch (error) {
     log(`Unable to resolve project via local session: ${error.message}`);
@@ -577,6 +593,7 @@ const BACKEND_PROFILE_MAP = {
   codex: "codex",
   claude: "claude-code",
   "claude-code": "claude-code",
+  copilot: "copilot",
 };
 
 function profileNameForBackend(backend) {
@@ -650,7 +667,12 @@ class TuiDriverSession {
       throw new Error(`Backend "${backend}" is not supported by tui-driver`);
     }
 
-    const baseProfile = profileName === "codex" ? codexProfile : claudeCodeProfile;
+    const profileMap = {
+      codex: codexProfile,
+      "claude-code": claudeCodeProfile,
+      copilot: copilotProfile,
+    };
+    const baseProfile = profileMap[profileName];
     const envConfig = loadEnvConfig(options.configFile);
     const proxyEnv = proxyToEnv(envConfig);
     const cliEnv = envConfig && typeof envConfig === "object" ? { ...envConfig, ...proxyEnv } : proxyEnv;
@@ -965,174 +987,6 @@ class TuiDriverSession {
   }
 }
 
-class ConductorClient {
-  constructor(client, transport, options = {}) {
-    this.client = client;
-    this.transport = transport;
-    this.closed = false;
-    this.projectPath = options.projectPath || process.cwd();
-  }
-
-  static async connect({ launcher, workingDirectory, extraEnv, projectPath }) {
-    if (!fs.existsSync(launcher.args[0])) {
-      throw new Error(`Conductor MCP server not found at ${launcher.args[0]}`);
-    }
-
-    const transport = new StdioClientTransport({
-      command: launcher.command,
-      args: launcher.args,
-      env: extraEnv,
-      cwd: launcher.cwd || workingDirectory,
-      stderr: "pipe",
-    });
-
-    const client = new Client({
-      name: CLI_NAME,
-      version: pkgJson.version,
-    });
-
-    client.onerror = (err) => {
-      log(`MCP client error: ${err.message}`);
-    };
-
-    const stderr = transport.stderr;
-    if (stderr) {
-      stderr.setEncoding("utf-8");
-      stderr.on("data", (chunk) => {
-        const text = chunk.toString();
-        const ts = new Date().toLocaleString("sv-SE", { timeZone: "Asia/Shanghai" }).replace(" ", "T");
-        text
-          .split(/\r?\n/)
-          .filter(Boolean)
-          .forEach((line) => process.stderr.write(`[conductor ${ts}] ${line}\n`));
-      });
-    }
-
-    await client.connect(transport);
-    return new ConductorClient(client, transport, { projectPath });
-  }
-
-  async close() {
-    if (this.closed) {
-      return;
-    }
-    this.closed = true;
-    await this.client.close();
-    await this.transport.close();
-  }
-
-  injectProjectPath(payload = {}) {
-    if (!this.projectPath || payload.project_path) {
-      return payload;
-    }
-    return { ...payload, project_path: this.projectPath };
-  }
-
-  async createTaskSession(payload) {
-    const args = payload ? { ...payload } : {};
-    return this.callTool("create_task_session", this.injectProjectPath(args));
-  }
-
-  async sendMessage(taskId, content, metadata) {
-    return this.callTool("send_message", {
-      task_id: taskId,
-      content,
-      metadata,
-    });
-  }
-
-  async sendTaskStatus(taskId, payload) {
-    return this.callTool("send_task_status", {
-      task_id: taskId,
-      ...(payload || {}),
-    });
-  }
-
-  async sendRuntimeStatus(taskId, payload) {
-    return this.callTool("send_runtime_status", {
-      task_id: taskId,
-      ...(payload || {}),
-    });
-  }
-
-  async receiveMessages(taskId, limit = 20) {
-    return this.callTool("receive_messages", {
-      task_id: taskId,
-      limit,
-    });
-  }
-
-  async ackMessages(taskId, ackToken) {
-    if (!ackToken) {
-      return;
-    }
-    await this.callTool("ack_messages", { task_id: taskId, ack_token: ackToken });
-  }
-
-  async listProjects() {
-    return this.callTool("list_projects", {});
-  }
-
-  async createProject(name, description, metadata) {
-    return this.callTool("create_project", {
-      name,
-      description,
-      metadata,
-    });
-  }
-
-  async getLocalProjectRecord() {
-    return this.callTool("get_local_project_id", this.injectProjectPath({}));
-  }
-
-  async matchProjectByPath() {
-    return this.callTool("match_project_by_path", this.injectProjectPath({}));
-  }
-
-  async bindProjectPath(projectId) {
-    return this.callTool("bind_project_path", this.injectProjectPath({ project_id: projectId }));
-  }
-
-  async callTool(name, args) {
-    const result = await this.client.callTool({
-      name,
-      arguments: args || {},
-    });
-    if (result?.isError) {
-      const message = extractFirstText(result?.content) || `tool ${name} failed`;
-      throw new Error(message);
-    }
-    const structured = result?.structuredContent;
-    if (structured && Object.keys(structured).length > 0) {
-      return structured;
-    }
-    const textPayload = extractFirstText(result?.content);
-    if (!textPayload) {
-      return undefined;
-    }
-    try {
-      return JSON.parse(textPayload);
-    } catch {
-      return textPayload;
-    }
-  }
-}
-
-function extractFirstText(blocks) {
-  if (!Array.isArray(blocks)) {
-    return "";
-  }
-  for (const block of blocks) {
-    if (block?.type === "text" && typeof block.text === "string") {
-      const trimmed = block.text.trim();
-      if (trimmed) {
-        return trimmed;
-      }
-    }
-  }
-  return "";
-}
-
 class BridgeRunner {
   constructor({
     backendSession,

package/package.json

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

package/src/daemon.js

@@ -59,6 +59,8 @@ function getAllowCliList(userConfig) {
 export function startDaemon(config = {}, deps = {}) {
   const exitFn = deps.exit || process.exit;
   const killFn = deps.kill || process.kill;
+  let requestShutdown = async () => {};
+  let shutdownSignalHandled = false;
 
   const exitAndReturn = (code) => {
     exitFn(code);
@@ -214,18 +216,31 @@ export function startDaemon(config = {}, deps = {}) {
   };
 
   process.on("exit", cleanupLock);
+  const handleSignal = (signal) => {
+    if (shutdownSignalHandled) return;
+    shutdownSignalHandled = true;
+    void (async () => {
+      try {
+        log(`Received ${signal}, shutting down...`);
+        await requestShutdown(`signal ${signal}`);
+      } catch (err) {
+        logError(`Graceful shutdown failed on ${signal}: ${err?.message || err}`);
+      } finally {
+        cleanupLock();
+        exitFn(0);
+      }
+    })();
+  };
   process.on("SIGINT", () => {
-    cleanupLock();
-    process.exit();
+    handleSignal("SIGINT");
   });
   process.on("SIGTERM", () => {
-    cleanupLock();
-    process.exit();
+    handleSignal("SIGTERM");
   });
   process.on("uncaughtException", (err) => {
     logError(`Uncaught exception: ${err}`);
     cleanupLock();
-    process.exit(1);
+    exitFn(1);
   });
 
   if (config.CLEAN_ALL) {
@@ -256,6 +271,7 @@ export function startDaemon(config = {}, deps = {}) {
   let disconnectedSinceLastConnectedLog = false;
   let didRecoverStaleTasks = false;
   const activeTaskProcesses = new Map();
+  const suppressedExitStatusReports = new Set();
   const client = createWebSocketClient(sdkConfig, {
     extraHeaders: {
       "x-conductor-host": AGENT_NAME,
@@ -652,6 +668,8 @@ export function startDaemon(config = {}, deps = {}) {
         clearTimeout(active.stopForceKillTimer);
       }
       activeTaskProcesses.delete(taskId);
+      const suppressExitStatusReport = suppressedExitStatusReports.has(taskId);
+      suppressedExitStatusReports.delete(taskId);
       if (logStream) {
         const ts = new Date().toLocaleString("sv-SE", { timeZone: "Asia/Shanghai" }).replace(" ", "T");
         if (signal) {
@@ -679,25 +697,59 @@ export function startDaemon(config = {}, deps = {}) {
           ? "completed"
           : `exited with code ${code}`;
 
-      client
-        .sendJson({
-          type: "task_status_update",
-          payload: {
-            task_id: taskId,
-            project_id: projectId,
-            status,
-            summary,
-          },
-        })
-        .catch((err) => {
-          logError(`Failed to report task status (${status}) for ${taskId}: ${err?.message || err}`);
-        });
+      if (!suppressExitStatusReport) {
+        client
+          .sendJson({
+            type: "task_status_update",
+            payload: {
+              task_id: taskId,
+              project_id: projectId,
+              status,
+              summary,
+            },
+          })
+          .catch((err) => {
+            logError(`Failed to report task status (${status}) for ${taskId}: ${err?.message || err}`);
+          });
+      }
     });
   }
 
-  return {
-    close: () => {
-      for (const [taskId, record] of activeTaskProcesses.entries()) {
+  let closePromise = null;
+  async function shutdownDaemon(reason = "manual close") {
+    if (closePromise) {
+      return closePromise;
+    }
+
+    closePromise = (async () => {
+      const activeEntries = [...activeTaskProcesses.entries()];
+      if (activeEntries.length > 0) {
+        log(`Shutdown requested (${reason}); stopping ${activeEntries.length} active task(s)`);
+      }
+
+      await Promise.allSettled(
+        activeEntries.map(async ([taskId, record]) => {
+          suppressedExitStatusReports.add(taskId);
+          try {
+            await client.sendJson({
+              type: "task_status_update",
+              payload: {
+                task_id: taskId,
+                project_id: record.projectId,
+                status: "KILLED",
+                summary: `daemon shutdown (${reason})`,
+              },
+            });
+          } catch (err) {
+            logError(`Failed to report shutdown status (KILLED) for ${taskId}: ${err?.message || err}`);
+          }
+        }),
+      );
+
+      for (const [taskId, record] of activeEntries) {
+        if (record?.stopForceKillTimer) {
+          clearTimeout(record.stopForceKillTimer);
+        }
         try {
           if (typeof record.child?.kill === "function") {
             record.child.kill("SIGTERM");
@@ -706,8 +758,24 @@ export function startDaemon(config = {}, deps = {}) {
           logError(`Failed to stop task ${taskId} on daemon close: ${error?.message || error}`);
         }
       }
+
       activeTaskProcesses.clear();
-      client.disconnect();
+
+      try {
+        await Promise.resolve(client.disconnect());
+      } catch (error) {
+        logError(`Failed to disconnect client on daemon close: ${error?.message || error}`);
+      }
+    })();
+
+    return closePromise;
+  }
+
+  requestShutdown = shutdownDaemon;
+
+  return {
+    close: () => {
+      void shutdownDaemon();
     },
   };
 }