@love-moon/conductor-cli 0.2.2 → 0.2.4

package/bin/conductor-fire.js

@@ -255,16 +255,32 @@ async function main() {
   });
 
   const signals = new AbortController();
-  process.on("SIGINT", () => signals.abort());
-  process.on("SIGTERM", () => signals.abort());
+  let shutdownSignal = null;
+  const onSigint = () => {
+    shutdownSignal = shutdownSignal || "SIGINT";
+    signals.abort();
+  };
+  const onSigterm = () => {
+    shutdownSignal = shutdownSignal || "SIGTERM";
+    signals.abort();
+  };
+  process.on("SIGINT", onSigint);
+  process.on("SIGTERM", onSigterm);
 
   try {
     await runner.start(signals.signal);
   } finally {
+    process.off("SIGINT", onSigint);
+    process.off("SIGTERM", onSigterm);
     if (typeof backendSession.close === "function") {
       await backendSession.close();
     }
     await conductor.close();
+    if (shutdownSignal === "SIGINT") {
+      process.exitCode = 130;
+    } else if (shutdownSignal === "SIGTERM") {
+      process.exitCode = 143;
+    }
   }
 }
 
@@ -664,6 +680,15 @@ class TuiDriverSession {
           }
         : undefined,
     });
+
+    // 监听登录需求事件
+    this.driver.on("login_required", (health) => {
+      log(`[${this.backend}] [WARN] Login required detected: ${health.message || health.reason}`);
+      if (health.matchedPattern) {
+        log(`[${this.backend}] [WARN] Matched pattern: "${health.matchedPattern}"`);
+      }
+      log(`[${this.backend}] [WARN] Please run "${this.command} login" or authenticate manually.`);
+    });
   }
 
   get threadId() {
@@ -680,6 +705,17 @@ class TuiDriverSession {
     }
   }
 
+  /**
+   * 获取当前健康状态
+   * @returns {Object} 健康状态对象 { healthy, reason, message, matchedPattern }
+   */
+  getHealthStatus() {
+    if (!this.driver) {
+      return { healthy: false, reason: "not_initialized", message: "Driver not initialized" };
+    }
+    return this.driver.healthCheck();
+  }
+
   buildPrompt(promptText, { useInitialImages = false } = {}) {
     let effectivePrompt = String(promptText || "").trim();
     if (!effectivePrompt) {
@@ -868,13 +904,41 @@ class TuiDriverSession {
       };
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      this.emitProgress(onProgress, {
-        state: "ERROR",
-        phase: "exception",
-        source: "tui-driver",
-        error: errorMessage,
-      });
-      log(`[${this.backend}] Error: ${errorMessage}`);
+      const errorReason = error?.reason || "unknown";
+
+      // 特殊处理登录和权限错误
+      if (errorReason === "login_required") {
+        this.emitProgress(onProgress, {
+          state: "ERROR",
+          phase: "login_required",
+          source: "tui-driver",
+          error: errorMessage,
+          reason: errorReason,
+          matched_pattern: error?.matchedPattern,
+        });
+        log(`[${this.backend}] Login required: ${errorMessage}`);
+        log(`[${this.backend}] Please run "${this.command} login" or authenticate manually.`);
+      } else if (errorReason === "permission_required") {
+        this.emitProgress(onProgress, {
+          state: "ERROR",
+          phase: "permission_required",
+          source: "tui-driver",
+          error: errorMessage,
+          reason: errorReason,
+          matched_pattern: error?.matchedPattern,
+        });
+        log(`[${this.backend}] Permission required: ${errorMessage}`);
+      } else {
+        this.emitProgress(onProgress, {
+          state: "ERROR",
+          phase: "exception",
+          source: "tui-driver",
+          error: errorMessage,
+          reason: errorReason,
+        });
+        log(`[${this.backend}] Error: ${errorMessage}`);
+      }
+
       const latestSignals = this.driver.getSignals();
       const summary = this.formatSignalSummary(latestSignals);
       this.trace(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "type": "module",
   "bin": {
     "conductor": "bin/conductor.js"
@@ -16,8 +16,8 @@
     "test": "node --test"
   },
   "dependencies": {
-    "@love-moon/tui-driver": "0.2.1",
-    "@love-moon/conductor-sdk": "0.2.2",
+    "@love-moon/tui-driver": "0.2.4",
+    "@love-moon/conductor-sdk": "0.2.4",
     "@modelcontextprotocol/sdk": "^1.20.2",
     "dotenv": "^16.4.5",
     "enquirer": "^2.4.1",
@@ -25,8 +25,7 @@
     "ws": "^8.18.0",
     "yargs": "^17.7.2",
     "chrome-launcher": "^1.2.1",
-    "chrome-remote-interface": "^0.33.0",
-    "@love-moon/cli2sdk": "0.2.2"
+    "chrome-remote-interface": "^0.33.0"
   },
   "pnpm": {
     "overrides": {

package/src/daemon.js

@@ -139,6 +139,10 @@ export function startDaemon(config = {}, deps = {}) {
     process.env.CONDUCTOR_PROJECT_PATH_LOOKUP_TIMEOUT_MS,
     1500,
   );
+  const STOP_FORCE_KILL_TIMEOUT_MS = parsePositiveInt(
+    process.env.CONDUCTOR_STOP_FORCE_KILL_TIMEOUT_MS,
+    5000,
+  );
 
   try {
     mkdirSyncFn(WORKSPACE_ROOT, { recursive: true });
@@ -250,6 +254,8 @@ export function startDaemon(config = {}, deps = {}) {
   });
 
   let disconnectedSinceLastConnectedLog = false;
+  let didRecoverStaleTasks = false;
+  const activeTaskProcesses = new Map();
   const client = createWebSocketClient(sdkConfig, {
     extraHeaders: {
       "x-conductor-host": AGENT_NAME,
@@ -260,6 +266,12 @@ export function startDaemon(config = {}, deps = {}) {
         log("Connected to backend");
       }
       disconnectedSinceLastConnectedLog = false;
+      if (!didRecoverStaleTasks) {
+        didRecoverStaleTasks = true;
+        recoverStaleTasks().catch((error) => {
+          logError(`recoverStaleTasks failed: ${error?.message || error}`);
+        });
+      }
     },
     onDisconnected: () => {
       disconnectedSinceLastConnectedLog = true;
@@ -274,9 +286,133 @@ export function startDaemon(config = {}, deps = {}) {
     logError(`Failed to connect: ${err}`);
   });
 
+  async function recoverStaleTasks() {
+    try {
+      const response = await fetchFn(`${BACKEND_HTTP}/api/tasks`, {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${AGENT_TOKEN}`,
+          Accept: "application/json",
+        },
+      });
+      if (!response.ok) {
+        logError(`Failed to recover stale tasks: HTTP ${response.status}`);
+        return;
+      }
+
+      const tasks = await response.json();
+      if (!Array.isArray(tasks) || tasks.length === 0) {
+        return;
+      }
+
+      const staleTasks = tasks.filter((task) => {
+        const status = String(task?.status || "").trim().toLowerCase();
+        const agentHost = String(task?.agent_host || "").trim();
+        return agentHost === AGENT_NAME && (status === "unknown" || status === "running");
+      });
+
+      if (staleTasks.length === 0) {
+        return;
+      }
+
+      await Promise.all(
+        staleTasks.map(async (task) => {
+          const taskId = task?.id;
+          if (!taskId) return;
+          const patchResp = await fetchFn(`${BACKEND_HTTP}/api/tasks/${taskId}`, {
+            method: "PATCH",
+            headers: {
+              Authorization: `Bearer ${AGENT_TOKEN}`,
+              Accept: "application/json",
+              "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ status: "killed" }),
+          });
+          if (!patchResp.ok) {
+            logError(`Failed to mark stale task ${taskId} as killed: HTTP ${patchResp.status}`);
+          }
+        }),
+      );
+
+      log(`Recovered ${staleTasks.length} stale task(s) to killed`);
+    } catch (error) {
+      logError(`recoverStaleTasks error: ${error?.message || error}`);
+    }
+  }
+
   function handleEvent(event) {
     if (event.type === "create_task") {
       handleCreateTask(event.payload);
+      return;
+    }
+    if (event.type === "stop_task") {
+      handleStopTask(event.payload);
+    }
+  }
+
+  function handleStopTask(payload) {
+    const taskId = payload?.task_id;
+    if (!taskId) return;
+
+    const requestId = payload?.request_id ? String(payload.request_id) : "";
+    const sendStopAck = (accepted) => {
+      if (!requestId) return;
+      client
+        .sendJson({
+          type: "task_stop_ack",
+          payload: {
+            task_id: taskId,
+            request_id: requestId,
+            accepted: Boolean(accepted),
+          },
+        })
+        .catch((err) => {
+          logError(`Failed to report task_stop_ack for ${taskId}: ${err?.message || err}`);
+        });
+    };
+
+    const record = activeTaskProcesses.get(taskId);
+    if (!record || !record.child) {
+      log(`Stop requested for task ${taskId}, but no active process found`);
+      sendStopAck(false);
+      return;
+    }
+
+    const reason = payload?.reason ? ` (${payload.reason})` : "";
+    log(`Stopping task ${taskId}${reason}`);
+
+    sendStopAck(true);
+
+    if (record.stopForceKillTimer) {
+      clearTimeout(record.stopForceKillTimer);
+      record.stopForceKillTimer = null;
+    }
+
+    try {
+      if (typeof record.child.kill === "function") {
+        record.child.kill("SIGTERM");
+      }
+    } catch (error) {
+      logError(`Failed to stop task ${taskId}: ${error?.message || error}`);
+    }
+
+    record.stopForceKillTimer = setTimeout(() => {
+      const latest = activeTaskProcesses.get(taskId);
+      if (!latest || latest.child !== record.child) {
+        return;
+      }
+      try {
+        if (typeof latest.child.kill === "function") {
+          log(`Task ${taskId} did not exit after SIGTERM, sending SIGKILL`);
+          latest.child.kill("SIGKILL");
+        }
+      } catch (error) {
+        logError(`Failed to SIGKILL task ${taskId}: ${error?.message || error}`);
+      }
+    }, STOP_FORCE_KILL_TIMEOUT_MS);
+
+    if (typeof record.stopForceKillTimer?.unref === "function") {
+      record.stopForceKillTimer.unref();
     }
   }
 
@@ -351,7 +487,7 @@ export function startDaemon(config = {}, deps = {}) {
           payload: {
             task_id: taskId,
             project_id: projectId,
-            status: "FAILED",
+            status: "KILLED",
             summary: `Unsupported backend: ${effectiveBackend}`,
           },
         })
@@ -370,11 +506,11 @@ export function startDaemon(config = {}, deps = {}) {
         payload: {
           task_id: taskId,
           project_id: projectId,
-          status: "CREATED",
+          status: "UNKNOWN",
         },
       })
       .catch((err) => {
-        logError(`Failed to report task status (CREATED) for ${taskId}: ${err?.message || err}`);
+        logError(`Failed to report task status (UNKNOWN) for ${taskId}: ${err?.message || err}`);
       });
 
     // Check if project has a bound local path for this daemon
@@ -470,6 +606,14 @@ export function startDaemon(config = {}, deps = {}) {
 
     log(`New task workspace: ${taskDir}`);
     log(`Logs: ${logPath}`);
+
+    activeTaskProcesses.set(taskId, {
+      child,
+      projectId,
+      logPath,
+      stopForceKillTimer: null,
+    });
+
     client
       .sendJson({
         type: "task_status_update",
@@ -502,15 +646,39 @@ export function startDaemon(config = {}, deps = {}) {
       }
     });
 
-    child.on("exit", (code) => {
+    child.on("exit", (code, signal) => {
+      const active = activeTaskProcesses.get(taskId);
+      if (active?.stopForceKillTimer) {
+        clearTimeout(active.stopForceKillTimer);
+      }
+      activeTaskProcesses.delete(taskId);
       if (logStream) {
         const ts = new Date().toLocaleString("sv-SE", { timeZone: "Asia/Shanghai" }).replace(" ", "T");
-        logStream.write(`[daemon ${ts}] process exited with code ${code}\n`);
+        if (signal) {
+          logStream.write(`[daemon ${ts}] process killed by signal ${signal}\n`);
+        } else {
+          logStream.write(`[daemon ${ts}] process exited with code ${code}\n`);
+        }
         logStream.end();
       }
-      log(`Task ${taskId} finished with code ${code}`);
+      if (signal) {
+        log(`Task ${taskId} killed by signal ${signal}`);
+      } else {
+        log(`Task ${taskId} finished with code ${code}`);
+      }
       log(`Logs: ${logPath}`);
-      const status = code === 0 ? "COMPLETED" : "FAILED";
+
+      const isKilledBySignal = Boolean(signal);
+      const isKilledByExitCode = code === 130 || code === 143;
+      const isKilled = isKilledBySignal || isKilledByExitCode;
+
+      const status = isKilled ? "KILLED" : code === 0 ? "COMPLETED" : "KILLED";
+      const summary = isKilled
+        ? (signal ? `killed by signal ${signal}` : `terminated (exit code ${code})`)
+        : code === 0
+          ? "completed"
+          : `exited with code ${code}`;
+
       client
         .sendJson({
           type: "task_status_update",
@@ -518,7 +686,7 @@ export function startDaemon(config = {}, deps = {}) {
             task_id: taskId,
             project_id: projectId,
             status,
-            summary: code === 0 ? "completed" : `exited with code ${code}`,
+            summary,
           },
         })
         .catch((err) => {
@@ -529,6 +697,16 @@ export function startDaemon(config = {}, deps = {}) {
 
   return {
     close: () => {
+      for (const [taskId, record] of activeTaskProcesses.entries()) {
+        try {
+          if (typeof record.child?.kill === "function") {
+            record.child.kill("SIGTERM");
+          }
+        } catch (error) {
+          logError(`Failed to stop task ${taskId} on daemon close: ${error?.message || error}`);
+        }
+      }
+      activeTaskProcesses.clear();
       client.disconnect();
     },
   };
@@ -540,7 +718,7 @@ async function cleanAllAgents(backendUrl, agentToken, fetchImpl) {
   const headers = {
     Authorization: `Bearer ${agentToken}`,
   };
-  const res = await fetch(target, { method: "GET", headers });
+  const res = await fetchFn(target, { method: "GET", headers });
   if (!res.ok) {
     throw new Error(`cleanup failed: ${res.status} ${res.statusText}`);
   }