@love-moon/conductor-cli 0.2.7 → 0.2.9

package/bin/conductor-fire.js

@@ -182,6 +182,45 @@ async function main() {
   log(`Using backend: ${cliArgs.backend}`);
 
   const env = buildEnv();
+  const launchedByDaemon = Boolean(process.env.CONDUCTOR_CLI_COMMAND);
+  let reconnectRunner = null;
+  let reconnectTaskId = null;
+  let conductor = null;
+  let reconnectResumeInFlight = false;
+
+  const scheduleReconnectRecovery = ({ isReconnect }) => {
+    if (!isReconnect) {
+      return;
+    }
+    log("Conductor connection restored");
+    if (reconnectRunner && typeof reconnectRunner.noteReconnect === "function") {
+      reconnectRunner.noteReconnect();
+    }
+    if (!conductor || !reconnectTaskId || reconnectResumeInFlight) {
+      return;
+    }
+    reconnectResumeInFlight = true;
+    void (async () => {
+      try {
+        await conductor.sendAgentResume({
+          active_tasks: [reconnectTaskId],
+          source: "conductor-fire",
+          metadata: { reconnect: true },
+        });
+        if (!launchedByDaemon) {
+          await conductor.sendTaskStatus(reconnectTaskId, {
+            status: "RUNNING",
+            summary: "conductor fire reconnected",
+          });
+        }
+      } catch (error) {
+        log(`Failed to report reconnect resume: ${error?.message || error}`);
+      } finally {
+        reconnectResumeInFlight = false;
+      }
+    })();
+  };
+
   if (cliArgs.configFile) {
     env.CONDUCTOR_CONFIG = cliArgs.configFile;
   }
@@ -200,10 +239,11 @@ async function main() {
     // Ignore config loading errors, rely on env vars or defaults
   }
 
-  const conductor = await ConductorClient.connect({
+  conductor = await ConductorClient.connect({
     projectPath: CLI_PROJECT_PATH,
     extraEnv: env,
     configFile: cliArgs.configFile,
+    onConnected: scheduleReconnectRecovery,
   });
 
   const taskContext = await ensureTaskContext(conductor, {
@@ -219,6 +259,17 @@ async function main() {
       taskContext.appUrl ? ` (${taskContext.appUrl})` : ""
     }`,
   );
+  reconnectTaskId = taskContext.taskId;
+
+  try {
+    await conductor.sendAgentResume({
+      active_tasks: [taskContext.taskId],
+      source: "conductor-fire",
+      metadata: { reconnect: false },
+    });
+  } catch (error) {
+    log(`Failed to report agent resume: ${error?.message || error}`);
+  }
 
   const runner = new BridgeRunner({
     backendSession,
@@ -230,10 +281,10 @@ async function main() {
     cliArgs: cliArgs.rawBackendArgs,
     backendName: cliArgs.backend,
   });
+  reconnectRunner = runner;
 
   const signals = new AbortController();
   let shutdownSignal = null;
-  const launchedByDaemon = Boolean(process.env.CONDUCTOR_CLI_COMMAND);
   const onSigint = () => {
     shutdownSignal = shutdownSignal || "SIGINT";
     signals.abort();
@@ -1010,6 +1061,8 @@ class BridgeRunner {
     this.runningTurn = false;
     this.processedMessageIds = new Set();
     this.lastRuntimeStatusSignature = null;
+    this.lastRuntimeStatusPayload = null;
+    this.needsReconnectRecovery = false;
   }
 
   async start(abortSignal) {
@@ -1025,6 +1078,9 @@ class BridgeRunner {
     await this.backfillPendingUserMessages();
 
     while (!this.stopped) {
+      if (this.needsReconnectRecovery && !this.runningTurn) {
+        await this.recoverAfterReconnect();
+      }
       let processed = false;
       try {
         processed = await this.processIncomingBatch();
@@ -1038,6 +1094,26 @@ class BridgeRunner {
     }
   }
 
+  noteReconnect() {
+    this.needsReconnectRecovery = true;
+  }
+
+  async recoverAfterReconnect() {
+    if (!this.needsReconnectRecovery) {
+      return;
+    }
+    this.needsReconnectRecovery = false;
+    log(`Recovering task ${this.taskId} after reconnect`);
+    // With durable web outbox enabled, user messages are replayed by the server.
+    // Re-running DB-history backfill here can re-drive stale prompts and confuse
+    // the local TUI session after reconnect. Keep startup backfill, but disable
+    // reconnect backfill by default (opt-in for debugging/legacy fallback).
+    if (process.env.CONDUCTOR_FIRE_RECONNECT_BACKFILL === "1") {
+      await this.backfillPendingUserMessages();
+    }
+    await this.replayLastRuntimeStatus();
+  }
+
   async processIncomingBatch() {
     const result = await this.conductor.receiveMessages(this.taskId, 20);
     const messages = Array.isArray(result?.messages) ? result.messages : [];
@@ -1159,6 +1235,9 @@ class BridgeRunner {
       return;
     }
     this.lastRuntimeStatusSignature = signature;
+    this.lastRuntimeStatusPayload = {
+      ...runtime,
+    };
 
     try {
       await this.conductor.sendRuntimeStatus(this.taskId, {
@@ -1170,6 +1249,20 @@ class BridgeRunner {
     }
   }
 
+  async replayLastRuntimeStatus() {
+    if (!this.lastRuntimeStatusPayload) {
+      return;
+    }
+    try {
+      await this.conductor.sendRuntimeStatus(this.taskId, {
+        ...this.lastRuntimeStatusPayload,
+        created_at: new Date().toISOString(),
+      });
+    } catch (error) {
+      log(`Failed to replay runtime status after reconnect: ${error?.message || error}`);
+    }
+  }
+
   async respondToMessage(message) {
     const content = String(message.content || "").trim();
     if (!content) {
@@ -1180,6 +1273,7 @@ class BridgeRunner {
       return;
     }
     this.lastRuntimeStatusSignature = null;
+    this.runningTurn = true;
     log(`Processing message ${replyTo} (${message.role})`);
     try {
       await this.reportRuntimeStatus(
@@ -1238,11 +1332,14 @@ class BridgeRunner {
         replyTo,
       );
       await this.reportError(`${this.backendName} 处理失败: ${errorMessage}`, replyTo);
+    } finally {
+      this.runningTurn = false;
     }
   }
 
   async handleSyntheticMessage(content, { includeImages }) {
     this.lastRuntimeStatusSignature = null;
+    this.runningTurn = true;
     try {
       const result = await this.backendSession.runTurn(content, {
         useInitialImages: includeImages,
@@ -1269,6 +1366,8 @@ class BridgeRunner {
       });
     } catch (error) {
       await this.reportError(`初始提示执行失败: ${error.message}`);
+    } finally {
+      this.runningTurn = false;
     }
   }
 

package/package.json

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

package/src/daemon.js

@@ -61,6 +61,7 @@ export function startDaemon(config = {}, deps = {}) {
   const killFn = deps.kill || process.kill;
   let requestShutdown = async () => {};
   let shutdownSignalHandled = false;
+  let forcedSignalExitHandled = false;
 
   const exitAndReturn = (code) => {
     exitFn(code);
@@ -145,6 +146,14 @@ export function startDaemon(config = {}, deps = {}) {
     process.env.CONDUCTOR_STOP_FORCE_KILL_TIMEOUT_MS,
     5000,
   );
+  const SHUTDOWN_STATUS_REPORT_TIMEOUT_MS = parsePositiveInt(
+    process.env.CONDUCTOR_SHUTDOWN_STATUS_REPORT_TIMEOUT_MS,
+    1000,
+  );
+  const SHUTDOWN_DISCONNECT_TIMEOUT_MS = parsePositiveInt(
+    process.env.CONDUCTOR_SHUTDOWN_DISCONNECT_TIMEOUT_MS,
+    1000,
+  );
 
   try {
     mkdirSyncFn(WORKSPACE_ROOT, { recursive: true });
@@ -216,8 +225,16 @@ export function startDaemon(config = {}, deps = {}) {
   };
 
   process.on("exit", cleanupLock);
+  const signalExitCode = (signal) => (signal === "SIGINT" ? 130 : 143);
   const handleSignal = (signal) => {
-    if (shutdownSignalHandled) return;
+    if (shutdownSignalHandled) {
+      if (forcedSignalExitHandled) return;
+      forcedSignalExitHandled = true;
+      log(`Received ${signal} again, forcing exit now`);
+      cleanupLock();
+      exitFn(signalExitCode(signal));
+      return;
+    }
     shutdownSignalHandled = true;
     void (async () => {
       try {
@@ -227,7 +244,7 @@ export function startDaemon(config = {}, deps = {}) {
         logError(`Graceful shutdown failed on ${signal}: ${err?.message || err}`);
       } finally {
         cleanupLock();
-        exitFn(0);
+        exitFn(signalExitCode(signal));
       }
     })();
   };
@@ -272,6 +289,7 @@ export function startDaemon(config = {}, deps = {}) {
   let didRecoverStaleTasks = false;
   const activeTaskProcesses = new Map();
   const suppressedExitStatusReports = new Set();
+  const seenCommandRequestIds = new Set();
   const client = createWebSocketClient(sdkConfig, {
     extraHeaders: {
       "x-conductor-host": AGENT_NAME,
@@ -282,11 +300,18 @@ export function startDaemon(config = {}, deps = {}) {
         log("Connected to backend");
       }
       disconnectedSinceLastConnectedLog = false;
+      sendAgentResume(isReconnect).catch((error) => {
+        logError(`sendAgentResume failed: ${error?.message || error}`);
+      });
       if (!didRecoverStaleTasks) {
         didRecoverStaleTasks = true;
         recoverStaleTasks().catch((error) => {
           logError(`recoverStaleTasks failed: ${error?.message || error}`);
         });
+      } else if (isReconnect) {
+        reconcileAssignedTasks().catch((error) => {
+          logError(`reconcileAssignedTasks failed: ${error?.message || error}`);
+        });
       }
     },
     onDisconnected: () => {
@@ -356,6 +381,102 @@ export function startDaemon(config = {}, deps = {}) {
     }
   }
 
+  async function reconcileAssignedTasks() {
+    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 reconcile tasks: HTTP ${response.status}`);
+        return;
+      }
+      const tasks = await response.json();
+      if (!Array.isArray(tasks)) {
+        return;
+      }
+      const localTaskIds = new Set(activeTaskProcesses.keys());
+      const assigned = tasks.filter((task) => {
+        const agentHost = String(task?.agent_host || "").trim();
+        const status = String(task?.status || "").trim().toLowerCase();
+        return agentHost === AGENT_NAME && (status === "unknown" || status === "running");
+      });
+
+      let killedCount = 0;
+      for (const task of assigned) {
+        const taskId = String(task?.id || "");
+        if (!taskId) continue;
+        if (localTaskIds.has(taskId)) {
+          continue;
+        }
+        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) {
+          killedCount += 1;
+        } else {
+          logError(`Failed to reconcile stale task ${taskId}: HTTP ${patchResp.status}`);
+        }
+      }
+
+      if (assigned.length || localTaskIds.size) {
+        log(
+          `Reconciled tasks after reconnect: backendAssigned=${assigned.length} localActive=${localTaskIds.size} markedKilled=${killedCount}`,
+        );
+      }
+    } catch (error) {
+      logError(`reconcileAssignedTasks error: ${error?.message || error}`);
+    }
+  }
+
+  async function sendAgentResume(isReconnect = false) {
+    await client.sendJson({
+      type: "agent_resume",
+      payload: {
+        active_tasks: [...activeTaskProcesses.keys()],
+        source: "conductor-daemon",
+        metadata: { is_reconnect: Boolean(isReconnect) },
+      },
+    });
+  }
+
+  function markRequestSeen(requestId) {
+    if (!requestId) return true;
+    if (seenCommandRequestIds.has(requestId)) {
+      return false;
+    }
+    seenCommandRequestIds.add(requestId);
+    if (seenCommandRequestIds.size > 2000) {
+      const first = seenCommandRequestIds.values().next();
+      if (!first.done) {
+        seenCommandRequestIds.delete(first.value);
+      }
+    }
+    return true;
+  }
+
+  function sendAgentCommandAck({ requestId, taskId, eventType, accepted = true }) {
+    if (!requestId) return Promise.resolve();
+    return client.sendJson({
+      type: "agent_command_ack",
+      payload: {
+        request_id: String(requestId),
+        task_id: taskId ? String(taskId) : undefined,
+        event_type: eventType,
+        accepted: Boolean(accepted),
+      },
+    });
+  }
+
   function handleEvent(event) {
     if (event.type === "create_task") {
       handleCreateTask(event.payload);
@@ -369,8 +490,18 @@ export function startDaemon(config = {}, deps = {}) {
   function handleStopTask(payload) {
     const taskId = payload?.task_id;
     if (!taskId) return;
-
     const requestId = payload?.request_id ? String(payload.request_id) : "";
+    if (requestId && !markRequestSeen(requestId)) {
+      log(`Duplicate stop_task ignored for ${taskId} (request_id=${requestId})`);
+      sendAgentCommandAck({
+        requestId,
+        taskId,
+        eventType: "stop_task",
+        accepted: true,
+      }).catch(() => {});
+      return;
+    }
+
     const sendStopAck = (accepted) => {
       if (!requestId) return;
       client
@@ -385,6 +516,14 @@ export function startDaemon(config = {}, deps = {}) {
         .catch((err) => {
           logError(`Failed to report task_stop_ack for ${taskId}: ${err?.message || err}`);
         });
+      sendAgentCommandAck({
+        requestId,
+        taskId,
+        eventType: "stop_task",
+        accepted,
+      }).catch((err) => {
+        logError(`Failed to report agent_command_ack(stop_task) for ${taskId}: ${err?.message || err}`);
+      });
     };
 
     const record = activeTaskProcesses.get(taskId);
@@ -485,11 +624,35 @@ export function startDaemon(config = {}, deps = {}) {
   }
 
   async function handleCreateTask(payload) {
-    const { task_id: taskId, project_id: projectId, backend_type: backendType, initial_content: initialContent } =
+    const {
+      task_id: taskId,
+      project_id: projectId,
+      backend_type: backendType,
+      initial_content: initialContent,
+      request_id: requestIdRaw,
+    } =
       payload || {};
+    const requestId = requestIdRaw ? String(requestIdRaw) : "";
 
     if (!taskId || !projectId) {
       logError(`Invalid create_task payload: ${JSON.stringify(payload)}`);
+      sendAgentCommandAck({
+        requestId,
+        taskId,
+        eventType: "create_task",
+        accepted: false,
+      }).catch(() => {});
+      return;
+    }
+
+    if (requestId && !markRequestSeen(requestId)) {
+      log(`Duplicate create_task ignored for ${taskId} (request_id=${requestId})`);
+      sendAgentCommandAck({
+        requestId,
+        taskId,
+        eventType: "create_task",
+        accepted: true,
+      }).catch(() => {});
       return;
     }
 
@@ -497,6 +660,12 @@ export function startDaemon(config = {}, deps = {}) {
     const effectiveBackend = backendType || SUPPORTED_BACKENDS[0];
     if (!SUPPORTED_BACKENDS.includes(effectiveBackend)) {
       logError(`Unsupported backend: ${effectiveBackend}. Supported: ${SUPPORTED_BACKENDS.join(", ")}`);
+      sendAgentCommandAck({
+        requestId,
+        taskId,
+        eventType: "create_task",
+        accepted: false,
+      }).catch(() => {});
       client
         .sendJson({
           type: "task_status_update",
@@ -511,6 +680,15 @@ export function startDaemon(config = {}, deps = {}) {
       return;
     }
 
+    sendAgentCommandAck({
+      requestId,
+      taskId,
+      eventType: "create_task",
+      accepted: true,
+    }).catch((err) => {
+      logError(`Failed to report agent_command_ack(create_task) for ${taskId}: ${err?.message || err}`);
+    });
+
     const cliCommand = ALLOW_CLI_LIST[effectiveBackend];
 
     log("");
@@ -731,15 +909,19 @@ export function startDaemon(config = {}, deps = {}) {
         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})`,
-              },
-            });
+            await withTimeout(
+              client.sendJson({
+                type: "task_status_update",
+                payload: {
+                  task_id: taskId,
+                  project_id: record.projectId,
+                  status: "KILLED",
+                  summary: `daemon shutdown (${reason})`,
+                },
+              }),
+              SHUTDOWN_STATUS_REPORT_TIMEOUT_MS,
+              `report shutdown status for ${taskId}`,
+            );
           } catch (err) {
             logError(`Failed to report shutdown status (KILLED) for ${taskId}: ${err?.message || err}`);
           }
@@ -762,7 +944,11 @@ export function startDaemon(config = {}, deps = {}) {
       activeTaskProcesses.clear();
 
       try {
-        await Promise.resolve(client.disconnect());
+        await withTimeout(
+          Promise.resolve(client.disconnect()),
+          SHUTDOWN_DISCONNECT_TIMEOUT_MS,
+          "disconnect daemon websocket",
+        );
       } catch (error) {
         logError(`Failed to disconnect client on daemon close: ${error?.message || error}`);
       }
@@ -828,6 +1014,25 @@ function parsePositiveInt(value, fallback) {
   return fallback;
 }
 
+async function withTimeout(promise, timeoutMs, label) {
+  let timer = null;
+  const timeoutPromise = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      reject(new Error(`${label} timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    if (typeof timer?.unref === "function") {
+      timer.unref();
+    }
+  });
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    if (timer) {
+      clearTimeout(timer);
+    }
+  }
+}
+
 function expandHomePath(inputPath, homeDir) {
   if (typeof inputPath !== "string" || !inputPath) {
     return inputPath;