@love-moon/conductor-cli 0.2.4 → 0.2.6

package/bin/conductor-fire.js

@@ -20,7 +20,7 @@ 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 { TuiDriver, claudeCodeProfile, codexProfile, copilotProfile } from "@love-moon/tui-driver";
 import { loadConfig } from "@love-moon/conductor-sdk";
 import {
   loadHistoryFromSpec,
@@ -145,7 +145,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)) {
@@ -256,6 +256,7 @@ async function main() {
 
   const signals = new AbortController();
   let shutdownSignal = null;
+  const launchedByDaemon = Boolean(process.env.CONDUCTOR_CLI_COMMAND);
   const onSigint = () => {
     shutdownSignal = shutdownSignal || "SIGINT";
     signals.abort();
@@ -272,6 +273,16 @@ async function main() {
   } finally {
     process.off("SIGINT", onSigint);
     process.off("SIGTERM", onSigterm);
+    if (shutdownSignal && !launchedByDaemon) {
+      try {
+        await conductor.sendTaskStatus(taskContext.taskId, {
+          status: "KILLED",
+          summary: `terminated by ${shutdownSignal}`,
+        });
+      } catch (error) {
+        log(`Failed to report task status (KILLED): ${error?.message || error}`);
+      }
+    }
     if (typeof backendSession.close === "function") {
       await backendSession.close();
     }
@@ -392,10 +403,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"
 
@@ -481,6 +494,7 @@ async function ensureTaskContext(conductor, opts) {
   const payload = {
     project_id: projectId,
     task_title: deriveTaskTitle(opts.initialPrompt, opts.requestedTitle, opts.backend),
+    backend_type: opts.backend,
   };
   if (opts.initialPrompt) {
     payload.prefill = opts.initialPrompt;
@@ -565,6 +579,7 @@ const BACKEND_PROFILE_MAP = {
   codex: "codex",
   claude: "claude-code",
   "claude-code": "claude-code",
+  copilot: "copilot",
 };
 
 function profileNameForBackend(backend) {
@@ -638,7 +653,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;
@@ -1029,6 +1049,13 @@ class ConductorClient {
     });
   }
 
+  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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "type": "module",
   "bin": {
     "conductor": "bin/conductor.js"
@@ -16,8 +16,8 @@
     "test": "node --test"
   },
   "dependencies": {
-    "@love-moon/tui-driver": "0.2.4",
-    "@love-moon/conductor-sdk": "0.2.4",
+    "@love-moon/tui-driver": "0.2.6",
+    "@love-moon/conductor-sdk": "0.2.6",
     "@modelcontextprotocol/sdk": "^1.20.2",
     "dotenv": "^16.4.5",
     "enquirer": "^2.4.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();
     },
   };
 }