@love-moon/conductor-cli 0.2.38 → 0.2.39

package/bin/conductor-fire.js

@@ -89,6 +89,13 @@ export function shouldRunReconnectRecovery({
   return !runner.shouldSuppressReconnectRecovery();
 }
 
+export function shouldFireReportTaskStatus({ launchedByDaemon = false, phase } = {}) {
+  if (phase === "final") {
+    return true;
+  }
+  return !launchedByDaemon;
+}
+
 // Load allow_cli_list from config file (no defaults - must be configured)
 function loadFireConfigYaml(configFilePath) {
   const home = os.homedir();
@@ -577,6 +584,39 @@ export class FireWatchdog {
   }
 }
 
+export function createPendingRemoteInterruptQueue() {
+  const pending = [];
+
+  return {
+    enqueue(event) {
+      return new Promise((resolve) => {
+        pending.push({ event, resolve });
+      });
+    },
+
+    async flushWith(dispatch) {
+      while (pending.length > 0) {
+        const next = pending.shift();
+        if (!next) {
+          continue;
+        }
+        try {
+          next.resolve(await dispatch(next.event));
+        } catch {
+          next.resolve(false);
+        }
+      }
+    },
+
+    rejectAll() {
+      while (pending.length > 0) {
+        const next = pending.shift();
+        next?.resolve(false);
+      }
+    },
+  };
+}
+
 async function main() {
   syncPwdEnvWithProcessCwdForDaemonLaunch();
   const cliArgs = await parseCliArgs();
@@ -637,6 +677,7 @@ async function main() {
   let reconnectRunner = null;
   let reconnectTaskId = null;
   let pendingRemoteStopEvent = null;
+  const pendingRemoteInterruptQueue = createPendingRemoteInterruptQueue();
   let conductor = null;
   let reconnectResumeInFlight = false;
   let fireShuttingDown = false;
@@ -676,7 +717,7 @@ async function main() {
           source: "conductor-fire",
           metadata: { reconnect: true },
         });
-        if (!launchedByDaemon) {
+        if (shouldFireReportTaskStatus({ launchedByDaemon, phase: "reconnect_running" })) {
           await conductor.sendTaskStatus(reconnectTaskId, {
             status: "RUNNING",
             summary: "conductor fire reconnected",
@@ -706,6 +747,21 @@ async function main() {
     pendingRemoteStopEvent = event;
   };
 
+  const handleInterruptTurnCommand = async (event) => {
+    fireWatchdog.onInbound();
+    if (!event || typeof event !== "object") {
+      return false;
+    }
+    const taskId = typeof event.taskId === "string" ? event.taskId : "";
+    if (reconnectTaskId && taskId && taskId !== reconnectTaskId) {
+      return false;
+    }
+    if (reconnectRunner && typeof reconnectRunner.requestInterruptFromRemote === "function") {
+      return await reconnectRunner.requestInterruptFromRemote(event);
+    }
+    return await pendingRemoteInterruptQueue.enqueue(event);
+  };
+
   if (cliArgs.configFile) {
     env.CONDUCTOR_CONFIG = cliArgs.configFile;
   }
@@ -756,6 +812,7 @@ async function main() {
         fireWatchdog.onPong(event);
       },
       onStopTask: handleStopTaskCommand,
+      onInterruptTurn: handleInterruptTurnCommand,
     });
 
     const taskContext = await ensureTaskContext(conductor, {
@@ -853,6 +910,7 @@ async function main() {
       await runner.requestStopFromRemote(pendingRemoteStopEvent);
       pendingRemoteStopEvent = null;
     }
+    await pendingRemoteInterruptQueue.flushWith((event) => runner.requestInterruptFromRemote(event));
 
     const signals = new AbortController();
     let shutdownSignal = null;
@@ -887,7 +945,7 @@ async function main() {
     process.on("SIGINT", onSigint);
     process.on("SIGTERM", onSigterm);
 
-    if (!launchedByDaemon) {
+    if (shouldFireReportTaskStatus({ launchedByDaemon, phase: "running" })) {
       try {
         await conductor.sendTaskStatus(taskContext.taskId, {
           status: "RUNNING",
@@ -911,7 +969,7 @@ async function main() {
     } finally {
       process.off("SIGINT", onSigint);
       process.off("SIGTERM", onSigterm);
-      if (!launchedByDaemon) {
+      if (shouldFireReportTaskStatus({ launchedByDaemon, phase: "final" })) {
         const remoteStopReason = typeof runner.getRemoteStopReason === "function" ? runner.getRemoteStopReason() : null;
         const remoteStopSummary = typeof runner.getRemoteStopSummary === "function" ? runner.getRemoteStopSummary() : null;
         // When the task was deleted by the user, the DB record is already gone —
@@ -934,10 +992,10 @@ async function main() {
                   status: "KILLED",
                   summary: remoteStopSummary,
                 }
-            : {
-                status: "COMPLETED",
-                summary: "conductor fire exited",
-              };
+              : {
+                  status: "COMPLETED",
+                  summary: "conductor fire exited",
+                };
         if (!taskDeletedByUser) {
           try {
             const statusResult = await conductor.sendTaskStatus(taskContext.taskId, finalStatus);
@@ -966,6 +1024,7 @@ async function main() {
       }
     }
   } finally {
+    pendingRemoteInterruptQueue.rejectAll();
     fireShuttingDown = true;
     fireWatchdog.stop();
     if (backendSession && typeof backendSession.close === "function") {
@@ -1731,6 +1790,9 @@ export class BridgeRunner {
       os.hostname();
     this.needsReconnectRecovery = false;
     this.remoteStopInfo = null;
+    this.remoteInterruptsByReplyTo = new Map();
+    this.pendingInterruptRetryTimers = new Map();
+    this.activeTurnReplyTo = "";
     this.sessionAnnouncementSent = false;
     this.boundSessionId = "";
     this.errorLoop = null;
@@ -1990,6 +2052,200 @@ export class BridgeRunner {
     }
   }
 
+  normalizeReplyTarget(replyTo) {
+    return typeof replyTo === "string" ? replyTo.trim() : "";
+  }
+
+  isTurnInterruptedError(error) {
+    const reason = typeof error?.reason === "string" ? error.reason.trim().toLowerCase() : "";
+    if (reason === "turn_interrupted" || reason === "turn_cancelled") {
+      return true;
+    }
+    const turnStatus = typeof error?.turnStatus === "string" ? error.turnStatus.trim().toLowerCase() : "";
+    if (
+      turnStatus === "interrupted" ||
+      turnStatus === "cancelled" ||
+      turnStatus === "canceled" ||
+      turnStatus === "aborted"
+    ) {
+      return true;
+    }
+    const name = typeof error?.name === "string" ? error.name.trim().toLowerCase() : "";
+    if (name === "aborterror") {
+      return true;
+    }
+    const message = String(error?.message || error || "").toLowerCase();
+    return (
+      message.includes(" interrupted") ||
+      message.includes("interrupt ") ||
+      message.includes("turn interrupted") ||
+      message.includes("cancelled") ||
+      message.includes("canceled") ||
+      message.includes("aborted")
+    );
+  }
+
+  async requestInterruptFromRemote(event = {}) {
+    const taskId = typeof event.taskId === "string" ? event.taskId.trim() : "";
+    if (taskId && taskId !== this.taskId) {
+      return false;
+    }
+    const requestId = typeof event.requestId === "string" ? event.requestId.trim() : "";
+    const reason = typeof event.reason === "string" ? event.reason.trim() : "";
+    const targetReplyTo = this.normalizeReplyTarget(event.targetReplyTo);
+    if (!targetReplyTo) {
+      return false;
+    }
+    if (this.processedMessageIds.has(targetReplyTo)) {
+      this.copilotLog(`ignore late interrupt_turn for processed replyTo=${targetReplyTo}`);
+      return false;
+    }
+
+    const existing = this.remoteInterruptsByReplyTo.get(targetReplyTo) || {};
+    const interruptInfo = {
+      requestId: requestId || existing.requestId || null,
+      reason: reason || existing.reason || "user_interrupt",
+      issued: Boolean(existing.issued),
+    };
+    this.remoteInterruptsByReplyTo.set(targetReplyTo, interruptInfo);
+    log(
+      `Received interrupt_turn for ${this.taskId} replyTo=${targetReplyTo}${
+        interruptInfo.reason ? ` (${interruptInfo.reason})` : ""
+      }`,
+    );
+    return await this.issueInterruptForReplyTarget(targetReplyTo);
+  }
+
+  async issueInterruptForReplyTarget(replyTo) {
+    const normalizedReplyTo = this.normalizeReplyTarget(replyTo);
+    if (!normalizedReplyTo) {
+      return false;
+    }
+    const interruptInfo = this.remoteInterruptsByReplyTo.get(normalizedReplyTo);
+    if (!interruptInfo) {
+      return false;
+    }
+    if (interruptInfo.issued) {
+      return true;
+    }
+    const supportsTurnInterrupt = typeof this.backendSession?.interruptCurrentTurn === "function";
+    const isActiveTarget = this.runningTurn && normalizedReplyTo === this.activeTurnReplyTo;
+    const isInFlightTarget = this.inFlightMessageIds.has(normalizedReplyTo);
+
+    if (!isActiveTarget && isInFlightTarget) {
+      this.copilotLog(`interrupt arrived after replyTo=${normalizedReplyTo} stopped being interruptible`);
+      return false;
+    }
+
+    if (!isActiveTarget) {
+      if (!supportsTurnInterrupt) {
+        log(`Backend session for ${this.taskId} does not support turn interruption`);
+        return false;
+      }
+      this.copilotLog(`queued interrupt request for future replyTo=${normalizedReplyTo}`);
+      return true;
+    }
+
+    if (!supportsTurnInterrupt) {
+      log(`Backend session for ${this.taskId} does not support turn interruption`);
+      return false;
+    }
+    try {
+      const interrupted = await this.backendSession.interruptCurrentTurn();
+      if (interrupted === false) {
+        interruptInfo.issued = false;
+        this.remoteInterruptsByReplyTo.set(normalizedReplyTo, interruptInfo);
+        if (
+          this.runningTurn &&
+          this.activeTurnReplyTo === normalizedReplyTo &&
+          this.inFlightMessageIds.has(normalizedReplyTo)
+        ) {
+          this.copilotLog(`backend interrupt not ready replyTo=${normalizedReplyTo}; retrying`);
+          this.scheduleInterruptRetryForReplyTarget(normalizedReplyTo);
+          return true;
+        }
+        return false;
+      }
+      interruptInfo.issued = true;
+      this.remoteInterruptsByReplyTo.set(normalizedReplyTo, interruptInfo);
+      this.copilotLog(`requested backend interrupt replyTo=${normalizedReplyTo}`);
+      return true;
+    } catch (error) {
+      interruptInfo.issued = false;
+      this.remoteInterruptsByReplyTo.set(normalizedReplyTo, interruptInfo);
+      log(`Failed to interrupt replyTo=${normalizedReplyTo} for ${this.taskId}: ${error?.message || error}`);
+      return false;
+    }
+  }
+
+  scheduleInterruptRetryForReplyTarget(replyTo) {
+    const normalizedReplyTo = this.normalizeReplyTarget(replyTo);
+    if (!normalizedReplyTo || this.pendingInterruptRetryTimers.has(normalizedReplyTo)) {
+      return;
+    }
+
+    const timer = setTimeout(() => {
+      this.pendingInterruptRetryTimers.delete(normalizedReplyTo);
+      const interruptInfo = this.remoteInterruptsByReplyTo.get(normalizedReplyTo);
+      if (
+        !interruptInfo ||
+        interruptInfo.issued ||
+        this.processedMessageIds.has(normalizedReplyTo) ||
+        !this.runningTurn ||
+        this.activeTurnReplyTo !== normalizedReplyTo ||
+        !this.inFlightMessageIds.has(normalizedReplyTo)
+      ) {
+        return;
+      }
+      void this.issueInterruptForReplyTarget(normalizedReplyTo);
+    }, 50);
+    if (typeof timer.unref === "function") {
+      timer.unref();
+    }
+    this.pendingInterruptRetryTimers.set(normalizedReplyTo, timer);
+  }
+
+  clearInterruptRetryForReplyTarget(replyTo) {
+    const normalizedReplyTo = this.normalizeReplyTarget(replyTo);
+    const timer = this.pendingInterruptRetryTimers.get(normalizedReplyTo);
+    if (!timer) {
+      return;
+    }
+    clearTimeout(timer);
+    this.pendingInterruptRetryTimers.delete(normalizedReplyTo);
+  }
+
+  async handleInterruptedTurn(replyTo, interruptInfo) {
+    const normalizedReplyTo = this.normalizeReplyTarget(replyTo);
+    this.clearInterruptRetryForReplyTarget(normalizedReplyTo);
+    this.copilotLog(`turn interrupted replyTo=${normalizedReplyTo || "latest"}`);
+    await this.reportRuntimeStatus(
+      {
+        phase: "interrupted",
+        reply_in_progress: false,
+        status_done_line: "Conversation interrupted",
+      },
+      normalizedReplyTo,
+    );
+    try {
+      await this.conductor.sendMessage(this.taskId, "Conversation interrupted", {
+        backend: this.backendName,
+        reply_to: normalizedReplyTo || undefined,
+        interrupted: true,
+        interruption_request_id: interruptInfo?.requestId || undefined,
+        reason: interruptInfo?.reason || undefined,
+        cli_args: this.cliArgs,
+      });
+    } catch (error) {
+      log(`Failed to send interrupt confirmation for ${this.taskId}: ${error?.message || error}`);
+    }
+    if (normalizedReplyTo) {
+      this.processedMessageIds.add(normalizedReplyTo);
+      this.remoteInterruptsByReplyTo.delete(normalizedReplyTo);
+    }
+    this.resetErrorLoop();
+  }
+
   async recoverAfterReconnect() {
     if (!this.needsReconnectRecovery) {
       return;
@@ -2502,6 +2758,7 @@ export class BridgeRunner {
     }
     this.lastRuntimeStatusSignature = null;
     this.runningTurn = true;
+    this.activeTurnReplyTo = this.normalizeReplyTarget(replyTo);
     const turnStartedAt = Date.now();
     let turnWatchdog = null;
     if (this.isCopilotBackend) {
@@ -2540,12 +2797,15 @@ export class BridgeRunner {
         );
       }
 
-      const result = await this.backendSession.runTurn(content, {
+      const turnPromise = this.backendSession.runTurn(content, {
         useInitialImages,
         onProgress: (payload) => {
           void this.reportRuntimeStatus(payload, replyTo);
         },
       });
+      await this.issueInterruptForReplyTarget(replyTo);
+      const result = await turnPromise;
+      this.activeTurnReplyTo = "";
       this.copilotLog(
         `runTurn completed replyTo=${replyTo || "latest"} elapsedMs=${Date.now() - turnStartedAt} answerLen=${String(
           result.text || "",
@@ -2582,6 +2842,10 @@ export class BridgeRunner {
         });
       }
       await this.syncBackendSessionBinding();
+      if (replyTo) {
+        this.clearInterruptRetryForReplyTarget(replyTo);
+        this.remoteInterruptsByReplyTo.delete(replyTo);
+      }
       if (replyTo) {
         this.processedMessageIds.add(replyTo);
       }
@@ -2600,6 +2864,7 @@ export class BridgeRunner {
         this.copilotLog(`sdk_message sent replyTo=${replyTo || "latest"} responseLen=${responseText.length}`);
       }
     } catch (error) {
+      this.activeTurnReplyTo = "";
       const errorMessage = error instanceof Error ? error.message : String(error);
       if (this.stopped && (this.remoteStopInfo || isSessionClosedError(error))) {
         this.copilotLog(
@@ -2607,6 +2872,11 @@ export class BridgeRunner {
         );
         return;
       }
+      const interruptInfo = replyTo ? this.remoteInterruptsByReplyTo.get(replyTo) : null;
+      if (interruptInfo && this.isTurnInterruptedError(error)) {
+        await this.handleInterruptedTurn(replyTo, interruptInfo);
+        return;
+      }
       if (await this.settleCodexCheckpointUnavailableAfterStream(replyTo, errorMessage)) {
         return;
       }
@@ -2663,7 +2933,9 @@ export class BridgeRunner {
       }
       if (replyTo) {
         this.inFlightMessageIds.delete(replyTo);
+        this.clearInterruptRetryForReplyTarget(replyTo);
       }
+      this.activeTurnReplyTo = "";
       this.copilotLog(
         `turn end replyTo=${replyTo || "latest"} elapsedMs=${Date.now() - turnStartedAt} processedIds=${this.processedMessageIds.size}`,
       );

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.2.38",
-  "gitCommitId": "6bf5515",
+  "version": "0.2.39",
+  "gitCommitId": "30204c8",
   "type": "module",
   "bin": {
     "conductor": "bin/conductor.js"
@@ -18,9 +18,9 @@
   },
   "dependencies": {
     "@love-moon/ai-bridge": "0.1.4",
-    "@love-moon/ai-manager": "0.2.38",
-    "@love-moon/ai-sdk": "0.2.38",
-    "@love-moon/conductor-sdk": "0.2.38",
+    "@love-moon/ai-manager": "0.2.39",
+    "@love-moon/ai-sdk": "0.2.39",
+    "@love-moon/conductor-sdk": "0.2.39",
     "chrome-launcher": "^1.2.1",
     "chrome-remote-interface": "^0.33.0",
     "dotenv": "^16.4.5",

package/src/daemon.js

@@ -1589,15 +1589,27 @@ export function startDaemon(config = {}, deps = {}) {
       }
     }
 
-    watchdogTimer = setInterval(() => {
+    const runMaintenanceTick = async () => {
       void runDaemonWatchdog();
-      // Auto-update checks (internally throttled)
-      void checkForUpdate().catch(() => {});
-      void tryAutoUpdate().catch(() => {});
+      try {
+        await checkForUpdate();
+      } catch {
+        // ignore non-critical version check failures
+      }
+      try {
+        await tryAutoUpdate();
+      } catch {
+        // ignore non-critical auto-update failures
+      }
+    };
+
+    watchdogTimer = setInterval(() => {
+      void runMaintenanceTick();
     }, DAEMON_WATCHDOG_INTERVAL_MS);
     if (typeof watchdogTimer?.unref === "function") {
       watchdogTimer.unref();
     }
+    void runMaintenanceTick();
   })();
 
   function markBackendHttpSuccess(at = Date.now()) {
@@ -3824,6 +3836,10 @@ export function startDaemon(config = {}, deps = {}) {
     return true;
   }
 
+  function shouldDaemonReportFireChildTerminalStatus(record) {
+    return !Boolean(record?.managedByFireBridge);
+  }
+
   function handleStopTask(payload) {
     const taskId = payload?.task_id;
     if (!taskId) return;
@@ -4326,6 +4342,7 @@ export function startDaemon(config = {}, deps = {}) {
         projectId,
         logPath,
         stopForceKillTimer: null,
+        managedByFireBridge: true,
       });
 
       client
@@ -4395,7 +4412,7 @@ export function startDaemon(config = {}, deps = {}) {
             ? "completed"
             : `exited with code ${code}`;
 
-        if (!suppressExitStatusReport) {
+        if (!suppressExitStatusReport && shouldDaemonReportFireChildTerminalStatus(active)) {
           client
             .sendJson({
               type: "task_status_update",
@@ -4750,6 +4767,7 @@ export function startDaemon(config = {}, deps = {}) {
       projectId: normalizedProjectId,
       logPath,
       stopForceKillTimer: null,
+      managedByFireBridge: true,
     });
 
     client
@@ -4812,7 +4830,7 @@ export function startDaemon(config = {}, deps = {}) {
           ? "completed"
           : `exited with code ${code}`;
 
-      if (!suppressExitStatusReport) {
+      if (!suppressExitStatusReport && shouldDaemonReportFireChildTerminalStatus(active)) {
         client
           .sendJson({
             type: "task_status_update",
@@ -4852,6 +4870,9 @@ export function startDaemon(config = {}, deps = {}) {
       await Promise.allSettled(
         activeEntries.map(async ([taskId, record]) => {
           suppressedExitStatusReports.add(taskId);
+          if (!shouldDaemonReportFireChildTerminalStatus(record)) {
+            return;
+          }
           try {
             await withTimeout(
               client.sendJson({

package/src/runtime-backends.js

@@ -28,7 +28,7 @@ function appendProviderModulePaths(parts, value) {
   if (!raw) {
     return;
   }
-  for (const item of raw.split(process.platform === "win32" ? ";" : ":")) {
+  for (const item of splitProviderModulePathString(raw)) {
     const normalized = item.trim();
     if (normalized) {
       parts.push(normalized);
@@ -36,6 +36,49 @@ function appendProviderModulePaths(parts, value) {
   }
 }
 
+function looksLikeProviderModulePath(value) {
+  const normalized = String(value || "").trim();
+  if (!normalized) {
+    return false;
+  }
+  return (
+    normalized.startsWith("/") ||
+    normalized.startsWith("./") ||
+    normalized.startsWith("../") ||
+    normalized.startsWith("~/") ||
+    normalized.startsWith("file:") ||
+    normalized.includes("/") ||
+    normalized.includes("\\") ||
+    /\.[cm]?[jt]sx?$/i.test(normalized) ||
+    /^[A-Za-z]:[\\/]/.test(normalized)
+  );
+}
+
+function splitProviderModulePathString(raw) {
+  const normalized = String(raw || "").trim();
+  if (!normalized) {
+    return [];
+  }
+
+  const platformParts = normalized
+    .split(path.delimiter)
+    .map((item) => item.trim())
+    .filter(Boolean);
+  if (platformParts.length > 1 || !normalized.includes(",")) {
+    return platformParts;
+  }
+
+  const commaParts = normalized
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean);
+  if (commaParts.length > 1 && commaParts.every(looksLikeProviderModulePath)) {
+    return commaParts;
+  }
+
+  return platformParts;
+}
+
 function listProviderModulePaths(providerPathEnv) {
   const parts = [];
   appendProviderModulePaths(parts, providerPathEnv);