@love-moon/conductor-cli 0.2.18 → 0.2.20

package/bin/conductor-fire.js

@@ -26,6 +26,7 @@ import {
   resolveSessionRunDirectory as resolveCliSessionRunDirectory,
   resumeProviderForBackend as resumeProviderForCliBackend,
 } from "../src/fire/resume.js";
+import { filterRuntimeSupportedAllowCliList, normalizeRuntimeBackendName } from "../src/runtime-backends.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -50,7 +51,7 @@ function loadAllowCliList(configFilePath) {
       const content = fs.readFileSync(configPath, "utf8");
       const parsed = yaml.load(content);
       if (parsed && typeof parsed === "object" && parsed.allow_cli_list) {
-        return parsed.allow_cli_list;
+        return filterRuntimeSupportedAllowCliList(parsed.allow_cli_list);
       }
     }
   } catch (error) {
@@ -59,6 +60,35 @@ function loadAllowCliList(configFilePath) {
   return {};
 }
 
+export function resolveAiSessionCommandLine(backend, allowCliList, env = process.env) {
+  const normalizedBackend = normalizeRuntimeBackendName(backend);
+  if (normalizedBackend !== "opencode") {
+    return "";
+  }
+
+  const opencodeEnvCommand =
+    typeof env?.CONDUCTOR_OPENCODE_COMMAND === "string" ? env.CONDUCTOR_OPENCODE_COMMAND.trim() : "";
+  if (opencodeEnvCommand) {
+    return opencodeEnvCommand;
+  }
+
+  const configuredCommand =
+    allowCliList && typeof allowCliList === "object" && typeof allowCliList.opencode === "string"
+      ? allowCliList.opencode.trim()
+      : "";
+  if (configuredCommand) {
+    return configuredCommand;
+  }
+
+  const daemonCommand =
+    typeof env?.CONDUCTOR_CLI_COMMAND === "string" ? env.CONDUCTOR_CLI_COMMAND.trim() : "";
+  if (daemonCommand) {
+    return daemonCommand;
+  }
+
+  return "";
+}
+
 const DEFAULT_POLL_INTERVAL_MS = parseInt(
   process.env.CONDUCTOR_CLI_POLL_INTERVAL_MS || process.env.CCODEX_POLL_INTERVAL_MS || "2000",
   10,
@@ -68,6 +98,30 @@ const DEFAULT_ERROR_LOOP_BACKOFF_MS = 3 * 60 * 1000;
 const DEFAULT_ERROR_LOOP_THRESHOLD = 3;
 const SESSION_BOOTSTRAP_LOCK_TIMEOUT_MS = 15_000;
 const SESSION_BOOTSTRAP_LOCK_RETRY_MS = 50;
+const FIRE_WATCHDOG_INTERVAL_MS = getBoundedEnvInt(
+  "CONDUCTOR_FIRE_WATCHDOG_INTERVAL_MS",
+  10_000,
+  1_000,
+  60_000,
+);
+const FIRE_WATCHDOG_STALE_WS_MS = getBoundedEnvInt(
+  "CONDUCTOR_FIRE_WATCHDOG_STALE_WS_MS",
+  45_000,
+  5_000,
+  5 * 60_000,
+);
+const FIRE_WATCHDOG_CONNECT_GRACE_MS = getBoundedEnvInt(
+  "CONDUCTOR_FIRE_WATCHDOG_CONNECT_GRACE_MS",
+  15_000,
+  1_000,
+  60_000,
+);
+const FIRE_WATCHDOG_RECONNECT_COOLDOWN_MS = getBoundedEnvInt(
+  "CONDUCTOR_FIRE_WATCHDOG_RECONNECT_COOLDOWN_MS",
+  15_000,
+  1_000,
+  2 * 60_000,
+);
 
 function sleepSync(ms) {
   if (!Number.isFinite(ms) || ms <= 0) {
@@ -161,6 +215,176 @@ function appendFireLocalLog(line) {
   }
 }
 
+function formatFireDisconnectDiagnostics(event = {}) {
+  const parts = [];
+  if (event.reason) {
+    parts.push(`reason=${event.reason}`);
+  }
+  if (typeof event.closeCode === "number") {
+    parts.push(`close_code=${event.closeCode}`);
+  }
+  if (event.closeReason) {
+    parts.push(`close_reason=${sanitizeForLog(event.closeReason, 120)}`);
+  }
+  if (event.socketError) {
+    parts.push(`socket_error=${sanitizeForLog(event.socketError, 120)}`);
+  }
+  if (typeof event.missedPongs === "number" && event.missedPongs > 0) {
+    parts.push(`missed_pongs=${event.missedPongs}`);
+  }
+  return parts.join(" ") || "reason=connection_lost";
+}
+
+function formatIsoTimestamp(value) {
+  if (!Number.isFinite(value) || value <= 0) {
+    return "n/a";
+  }
+  return new Date(value).toISOString();
+}
+
+function formatFireWatchdogState({ connectedAt, lastPongAt, lastInboundAt }) {
+  return [
+    `connected_at=${formatIsoTimestamp(connectedAt)}`,
+    `last_pong_at=${formatIsoTimestamp(lastPongAt)}`,
+    `last_inbound_at=${formatIsoTimestamp(lastInboundAt)}`,
+  ].join(" ");
+}
+
+export class FireWatchdog {
+  constructor({
+    intervalMs = FIRE_WATCHDOG_INTERVAL_MS,
+    staleWsMs = FIRE_WATCHDOG_STALE_WS_MS,
+    connectGraceMs = FIRE_WATCHDOG_CONNECT_GRACE_MS,
+    reconnectCooldownMs = FIRE_WATCHDOG_RECONNECT_COOLDOWN_MS,
+    onForceReconnect,
+    logger = () => {},
+    now = () => Date.now(),
+  } = {}) {
+    this.intervalMs = intervalMs;
+    this.staleWsMs = staleWsMs;
+    this.connectGraceMs = connectGraceMs;
+    this.reconnectCooldownMs = reconnectCooldownMs;
+    this.onForceReconnect = onForceReconnect;
+    this.logger = logger;
+    this.now = now;
+    this.wsConnected = false;
+    this.lastConnectedAt = null;
+    this.lastPongAt = null;
+    this.lastInboundAt = null;
+    this.lastHealAt = 0;
+    this.healAttempts = 0;
+    this.awaitingHealthySignalAt = null;
+    this.timer = null;
+  }
+
+  start() {
+    if (this.timer) {
+      return;
+    }
+    this.timer = setInterval(() => {
+      void this.runOnce();
+    }, this.intervalMs);
+    if (typeof this.timer.unref === "function") {
+      this.timer.unref();
+    }
+  }
+
+  stop() {
+    if (!this.timer) {
+      return;
+    }
+    clearInterval(this.timer);
+    this.timer = null;
+  }
+
+  onConnected({ isReconnect = false, connectedAt = this.now() } = {}) {
+    this.wsConnected = true;
+    this.lastConnectedAt = connectedAt;
+    this.lastPongAt =
+      Number.isFinite(this.lastPongAt) && this.lastPongAt > connectedAt ? this.lastPongAt : connectedAt;
+    if (isReconnect && this.healAttempts > 0) {
+      this.awaitingHealthySignalAt = connectedAt;
+    } else if (!isReconnect) {
+      this.awaitingHealthySignalAt = null;
+    }
+  }
+
+  onDisconnected() {
+    this.wsConnected = false;
+  }
+
+  onPong({ at = this.now() } = {}) {
+    this.lastPongAt = at;
+    this.markHealthy("pong", at);
+  }
+
+  onInbound(at = this.now()) {
+    this.lastInboundAt = at;
+    this.markHealthy("inbound", at);
+  }
+
+  markHealthy(signal, at = this.now()) {
+    if (!this.awaitingHealthySignalAt || this.healAttempts === 0) {
+      return;
+    }
+    if (at < this.awaitingHealthySignalAt) {
+      return;
+    }
+    this.logger(
+      `[watchdog] Backend websocket healthy again after self-heal via ${signal} (${formatFireWatchdogState({
+        connectedAt: this.lastConnectedAt,
+        lastPongAt: this.lastPongAt,
+        lastInboundAt: this.lastInboundAt,
+      })})`,
+    );
+    this.awaitingHealthySignalAt = null;
+    this.healAttempts = 0;
+  }
+
+  async runOnce() {
+    if (!this.wsConnected || typeof this.onForceReconnect !== "function") {
+      return false;
+    }
+    const now = this.now();
+    if (!Number.isFinite(this.lastConnectedAt) || now - this.lastConnectedAt < this.connectGraceMs) {
+      return false;
+    }
+    const lastWsHealthAt = Math.max(this.lastPongAt || 0, this.lastInboundAt || 0, this.lastConnectedAt || 0);
+    if (lastWsHealthAt && now - lastWsHealthAt <= this.staleWsMs) {
+      return false;
+    }
+    if (this.lastHealAt && now - this.lastHealAt < this.reconnectCooldownMs) {
+      return false;
+    }
+
+    this.lastHealAt = now;
+    this.healAttempts += 1;
+    this.awaitingHealthySignalAt = null;
+    this.wsConnected = false;
+    this.logger(
+      `[watchdog] stale_ws_health; restarting fire websocket (${this.healAttempts}) (${formatFireWatchdogState({
+        connectedAt: this.lastConnectedAt,
+        lastPongAt: this.lastPongAt,
+        lastInboundAt: this.lastInboundAt,
+      })})`,
+    );
+    await this.onForceReconnect("watchdog:stale_ws_health");
+    return true;
+  }
+
+  getDebugState() {
+    return {
+      wsConnected: this.wsConnected,
+      lastConnectedAt: this.lastConnectedAt,
+      lastPongAt: this.lastPongAt,
+      lastInboundAt: this.lastInboundAt,
+      lastHealAt: this.lastHealAt,
+      healAttempts: this.healAttempts,
+      awaitingHealthySignalAt: this.awaitingHealthySignalAt,
+    };
+  }
+}
+
 async function main() {
   const cliArgs = parseCliArgs();
   let runtimeProjectPath = process.cwd();
@@ -180,7 +404,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    copilot: copilot --allow-all-paths --allow-all-tools\n    kimi: kimi\n`);
+      process.stdout.write(`No supported 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    opencode: opencode\n`);
     } else {
       process.stdout.write(`Supported backends (from config):\n`);
       for (const [name, command] of Object.entries(allowCliList)) {
@@ -209,6 +433,17 @@ async function main() {
   let pendingRemoteStopEvent = null;
   let conductor = null;
   let reconnectResumeInFlight = false;
+  let fireShuttingDown = false;
+  const fireWatchdog = new FireWatchdog({
+    onForceReconnect: async (reason) => {
+      if (!conductor || typeof conductor.forceReconnect !== "function") {
+        return;
+      }
+      await conductor.forceReconnect(reason);
+    },
+    logger: log,
+  });
+  fireWatchdog.start();
 
   const scheduleReconnectRecovery = ({ isReconnect }) => {
     if (!isReconnect) {
@@ -244,6 +479,7 @@ async function main() {
   };
 
   const handleStopTaskCommand = async (event) => {
+    fireWatchdog.onInbound();
     if (!event || typeof event !== "object") {
       return;
     }
@@ -292,7 +528,19 @@ async function main() {
       projectPath: runtimeProjectPath,
       extraEnv: env,
       configFile: cliArgs.configFile,
-      onConnected: scheduleReconnectRecovery,
+      onConnected: (event) => {
+        fireWatchdog.onConnected(event);
+        scheduleReconnectRecovery(event);
+      },
+      onDisconnected: (event) => {
+        fireWatchdog.onDisconnected();
+        if (!fireShuttingDown) {
+          log(`[fire-ws] Disconnected from backend: ${formatFireDisconnectDiagnostics(event)}`);
+        }
+      },
+      onPong: (event) => {
+        fireWatchdog.onPong(event);
+      },
       onStopTask: handleStopTaskCommand,
     });
 
@@ -333,11 +581,14 @@ async function main() {
 
     const resolvedResumeSessionId = cliArgs.resumeSessionId;
 
+    const sessionCommandLine = resolveAiSessionCommandLine(cliArgs.backend, allowCliList, process.env);
+
     backendSession = createAiSession(cliArgs.backend, {
       initialImages: cliArgs.initialImages,
       cwd: runtimeProjectPath,
       resumeSessionId: resolvedResumeSessionId,
       configFile: cliArgs.configFile,
+      ...(sessionCommandLine ? { commandLine: sessionCommandLine } : {}),
       logger: { log },
     });
 
@@ -359,6 +610,7 @@ async function main() {
       taskId: taskContext.taskId,
       pollIntervalMs: Math.max(cliArgs.pollIntervalMs, 500),
       initialPrompt: taskContext.shouldProcessInitialPrompt ? cliArgs.initialPrompt : "",
+      initialPromptDelivery: taskContext.initialPromptDelivery || "none",
       includeInitialImages: Boolean(cliArgs.initialPrompt && cliArgs.initialImages.length),
       cliArgs: cliArgs.rawBackendArgs,
       backendName: cliArgs.backend,
@@ -391,11 +643,13 @@ async function main() {
     };
     const onSigint = () => {
       shutdownSignal = shutdownSignal || "SIGINT";
+      fireShuttingDown = true;
       signals.abort();
       requestBackendShutdown("SIGINT");
     };
     const onSigterm = () => {
       shutdownSignal = shutdownSignal || "SIGTERM";
+      fireShuttingDown = true;
       signals.abort();
       requestBackendShutdown("SIGTERM");
     };
@@ -460,6 +714,8 @@ async function main() {
       }
     }
   } finally {
+    fireShuttingDown = true;
+    fireWatchdog.stop();
     if (backendSession && typeof backendSession.close === "function") {
       try {
         await backendSession.close();
@@ -578,7 +834,6 @@ export function parseCliArgs(argvInput = process.argv) {
       alias: "b",
       type: "string",
       describe: `Backend to use (loaded from config: ${supportedBackends.join(", ") || "none configured"})`,
-      ...(supportedBackends.length > 0 ? { choices: supportedBackends } : {}),
     })
     .option("list-backends", {
       type: "boolean",
@@ -640,12 +895,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
+    opencode: opencode
 
 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} --backend opencode -- "fix the bug" # Use OpenCode backend
   ${CLI_NAME} --backend codex --resume <id>       # Resume Codex session
   ${CLI_NAME} --list-backends                     # Show configured backends
   ${CLI_NAME} --config-file ~/.conductor/config.yaml -- "fix the bug"
@@ -668,7 +923,22 @@ Environment:
     })
     .parse();
   
-  const backend = conductorArgs.backend || supportedBackends[0];
+  const backend = conductorArgs.backend
+    ? normalizeRuntimeBackendName(conductorArgs.backend)
+    : supportedBackends[0];
+  const shouldRequireBackend =
+    !Boolean(conductorArgs.listBackends) &&
+    !listBackendsWithoutSeparator &&
+    !Boolean(conductorArgs.version) &&
+    !versionWithoutSeparator;
+  if (backend && !supportedBackends.includes(backend) && shouldRequireBackend) {
+    throw new Error(
+      `Unsupported backend "${backend}". Supported backends: ${supportedBackends.join(", ") || "none configured"}.`,
+    );
+  }
+  if (!backend && shouldRequireBackend) {
+    throw new Error("No supported backends configured. Add codex, claude, or opencode to allow_cli_list.");
+  }
 
   const prompt = (backendArgs._ || []).map((part) => String(part)).join(" ").trim();
   const initialImages = normalizeArray(backendArgs.image || backendArgs.i).map((img) => String(img));
@@ -806,6 +1076,7 @@ async function ensureTaskContext(conductor, opts) {
       taskId: opts.providedTaskId,
       appUrl: null,
       shouldProcessInitialPrompt: Boolean(opts.initialPrompt),
+      initialPromptDelivery: opts.initialPrompt ? "synthetic" : "none",
     };
   }
 
@@ -837,6 +1108,7 @@ async function ensureTaskContext(conductor, opts) {
     taskId: session.task_id,
     appUrl: session.app_url || null,
     shouldProcessInitialPrompt: Boolean(opts.initialPrompt),
+    initialPromptDelivery: opts.initialPrompt ? "queued" : "none",
   };
 }
 
@@ -1016,6 +1288,7 @@ export class BridgeRunner {
     taskId,
     pollIntervalMs,
     initialPrompt,
+    initialPromptDelivery,
     includeInitialImages,
     cliArgs,
     backendName,
@@ -1027,6 +1300,10 @@ export class BridgeRunner {
     this.taskId = taskId;
     this.pollIntervalMs = pollIntervalMs;
     this.initialPrompt = initialPrompt;
+    this.initialPromptDelivery =
+      typeof initialPromptDelivery === "string" && initialPromptDelivery.trim()
+        ? initialPromptDelivery.trim()
+        : "none";
     this.includeInitialImages = includeInitialImages;
     this.cliArgs = cliArgs;
     this.backendName = backendName || "codex";
@@ -1042,6 +1319,10 @@ export class BridgeRunner {
     this.runningTurn = false;
     this.processedMessageIds = new Set();
     this.inFlightMessageIds = new Set();
+    this.pendingInitialPrompt =
+      this.initialPromptDelivery === "queued" && typeof initialPrompt === "string" && initialPrompt.trim()
+        ? initialPrompt.trim()
+        : "";
     this.sessionStreamReplyCounts = new Map();
     this.lastRuntimeStatusSignature = null;
     this.lastRuntimeStatusPayload = null;
@@ -1230,8 +1511,8 @@ export class BridgeRunner {
       return;
     }
 
-    if (this.initialPrompt) {
-      this.copilotLog("processing initial prompt");
+    if (this.initialPrompt && this.initialPromptDelivery === "synthetic") {
+      this.copilotLog("processing initial prompt via synthetic attach flow");
       await this.handleSyntheticMessage(this.initialPrompt, {
         includeImages: this.includeInitialImages,
       });
@@ -1239,6 +1520,7 @@ export class BridgeRunner {
     if (this.stopped) {
       return;
     }
+
     while (!this.stopped) {
       if (this.needsReconnectRecovery && !this.runningTurn) {
         await this.recoverAfterReconnect();
@@ -1783,6 +2065,11 @@ export class BridgeRunner {
     if (replyTo) {
       this.inFlightMessageIds.add(replyTo);
     }
+    const isQueuedInitialPromptMessage =
+      Boolean(this.pendingInitialPrompt) &&
+      String(message.role || "").toLowerCase() === "user" &&
+      content === this.pendingInitialPrompt;
+    const useInitialImages = isQueuedInitialPromptMessage && this.includeInitialImages;
     if (
       this.useSessionFileReplyStream &&
       typeof this.backendSession?.setSessionReplyTarget === "function"
@@ -1830,6 +2117,7 @@ export class BridgeRunner {
       }
 
       const result = await this.backendSession.runTurn(content, {
+        useInitialImages,
         onProgress: (payload) => {
           void this.reportRuntimeStatus(payload, replyTo);
         },
@@ -1873,6 +2161,9 @@ export class BridgeRunner {
       if (replyTo) {
         this.processedMessageIds.add(replyTo);
       }
+      if (isQueuedInitialPromptMessage) {
+        this.pendingInitialPrompt = "";
+      }
       this.resetErrorLoop();
       if (this.useSessionFileReplyStream) {
         this.copilotLog(`session_file turn settled replyTo=${replyTo || "latest"}`);

package/bin/conductor.js

@@ -10,6 +10,7 @@
  *   update   - Update the CLI to the latest version
  *   diagnose - Diagnose a task in production/backend
  *   send-file - Upload a local file into a task session
+ *   channel  - Connect user-owned chat channel providers
  */
 
 import { fileURLToPath } from "node:url";
@@ -46,7 +47,7 @@ if (argv[0] === "--version" || argv[0] === "-v") {
 const subcommand = argv[0];
 
 // Valid subcommands
-const validSubcommands = ["fire", "daemon", "config", "update", "diagnose", "send-file"];
+const validSubcommands = ["fire", "daemon", "config", "update", "diagnose", "send-file", "channel"];
 
 if (!validSubcommands.includes(subcommand)) {
   console.error(`Error: Unknown subcommand '${subcommand}'`);
@@ -90,6 +91,7 @@ Subcommands:
   update    Update the CLI to the latest version
   diagnose  Diagnose a task and print likely root cause
   send-file Upload a local file into a task session
+  channel   Connect user-owned chat channel providers
 
 Options:
   -h, --help     Show this help message
@@ -101,6 +103,7 @@ Examples:
   conductor daemon --config-file ~/.conductor/config.yaml
   conductor diagnose <task-id>
   conductor send-file ./screenshot.png
+  conductor channel connect feishu
   conductor config
   conductor update
 
@@ -111,6 +114,7 @@ For subcommand-specific help:
   conductor update --help
   conductor diagnose --help
   conductor send-file --help
+  conductor channel --help
 
 Version: ${pkgJson.version}
 `);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.2.18",
-  "gitCommitId": "942418b",
+  "version": "0.2.20",
+  "gitCommitId": "d622756",
   "type": "module",
   "bin": {
     "conductor": "bin/conductor.js"
@@ -17,17 +17,25 @@
     "test": "node --test test/*.test.js"
   },
   "dependencies": {
-    "@love-moon/ai-sdk": "0.2.18",
-    "@love-moon/conductor-sdk": "0.2.18",
+    "@love-moon/ai-sdk": "0.2.20",
+    "@love-moon/conductor-sdk": "0.2.20",
     "dotenv": "^16.4.5",
     "enquirer": "^2.4.1",
     "js-yaml": "^4.1.1",
+    "node-pty": "^1.0.0",
     "ws": "^8.18.0",
     "yargs": "^17.7.2",
     "chrome-launcher": "^1.2.1",
     "chrome-remote-interface": "^0.33.0"
   },
+  "optionalDependencies": {
+    "@roamhq/wrtc": "^0.10.0"
+  },
   "pnpm": {
+    "onlyBuiltDependencies": [
+      "node-pty",
+      "@roamhq/wrtc"
+    ],
     "overrides": {
       "@love-moon/ai-sdk": "file:../modules/ai-sdk",
       "@love-moon/conductor-sdk": "file:../modules/conductor-sdk"