@love-moon/conductor-cli 0.2.39 → 0.2.41

package/bin/conductor-config.js

@@ -37,6 +37,11 @@ const DEFAULT_CLIs = {
     execArgs: "",
     description: "OpenCode CLI (Conductor runs opencode serve with permission=allow)"
   },
+  copilot: {
+    command: "copilot",
+    execArgs: "",
+    description: "GitHub Copilot (built in via SDK)"
+  },
 };
 
 const backendUrl =
@@ -63,6 +68,13 @@ function colorize(text, color) {
   return `${COLORS[color] || ""}${text}${COLORS.reset}`;
 }
 
+function isBuiltInCopilotAvailable() {
+  return Boolean(
+    packageJson?.dependencies?.["@github/copilot-sdk"] ||
+    packageJson?.optionalDependencies?.["@github/copilot-sdk"],
+  );
+}
+
 function buildConfigEntryLines(cli, info, { commented = false } = {}) {
   const fullCommand = info.execArgs
     ? `${info.command} ${info.execArgs}`
@@ -278,6 +290,10 @@ function detectInstalledCLIs() {
     if (!RUNTIME_SUPPORTED_BACKENDS.includes(key)) {
       continue;
     }
+    if (key === "copilot" && isBuiltInCopilotAvailable()) {
+      detected.push(key);
+      continue;
+    }
     if (isCommandAvailable(info.command)) {
       detected.push(key);
     }

package/bin/conductor-fire.js

@@ -29,7 +29,9 @@ import {
 import {
   filterRuntimeSupportedAllowCliList,
   isBuiltInRuntimeBackend,
+  isCommandOptionalBuiltInRuntimeBackend,
   listAdvertisedBackends,
+  parseCommandParts,
   resolveConfiguredRuntimeBackend,
   normalizeRuntimeBackendAlias,
   normalizeRuntimeBackendName,
@@ -69,9 +71,20 @@ const CLI_NAME = (process.env.CONDUCTOR_CLI_NAME || path.basename(process.argv[1
   "",
 );
 
-export function buildConductorConnectHeaders(version = pkgJson.version) {
+export function buildConductorConnectHeaders(
+  version = pkgJson.version,
+  options = {},
+) {
+  const backends = Array.isArray(options.backends)
+    ? options.backends.map((entry) => String(entry || "").trim()).filter(Boolean)
+    : [];
+  const capabilities = Array.isArray(options.capabilities)
+    ? options.capabilities.map((entry) => String(entry || "").trim()).filter(Boolean)
+    : [];
   return {
     "x-conductor-version": version,
+    ...(backends.length > 0 ? { "x-conductor-backends": backends.join(",") } : {}),
+    ...(capabilities.length > 0 ? { "x-conductor-capabilities": capabilities.join(",") } : {}),
   };
 }
 
@@ -155,70 +168,8 @@ export function resolveConfiguredPrePrompt({ configFilePath, backend, sessionBac
   return undefined;
 }
 
-function parseCommandParts(commandLine) {
-  const input = String(commandLine || "").trim();
-  if (!input) {
-    return [];
-  }
-
-  const parts = [];
-  let current = "";
-  let quote = "";
-  let escaping = false;
-  let tokenStarted = false;
-
-  for (const char of input) {
-    if (escaping) {
-      current += char;
-      tokenStarted = true;
-      escaping = false;
-      continue;
-    }
-
-    if (char === "\\") {
-      escaping = true;
-      tokenStarted = true;
-      continue;
-    }
-
-    if (quote) {
-      if (char === quote) {
-        quote = "";
-      } else {
-        current += char;
-      }
-      tokenStarted = true;
-      continue;
-    }
-
-    if (char === "'" || char === "\"") {
-      quote = char;
-      tokenStarted = true;
-      continue;
-    }
-
-    if (/\s/.test(char)) {
-      if (tokenStarted) {
-        parts.push(current);
-        current = "";
-        tokenStarted = false;
-      }
-      continue;
-    }
-
-    current += char;
-    tokenStarted = true;
-  }
-
-  if (tokenStarted) {
-    parts.push(current);
-  }
-
-  return parts;
-}
-
 function extractModelOptionFromCommandLine(commandLine) {
-  const parts = parseCommandParts(commandLine);
+  const { parts } = parseCommandParts(commandLine);
   for (let index = 0; index < parts.length; index += 1) {
     const token = String(parts[index] || "").trim();
     if (!token) {
@@ -664,7 +615,8 @@ async function main() {
   let resumeContext = null;
   if (cliArgs.resumeSessionId) {
     const bootstrap = await bootstrapResumeContextForFire({
-      backend: cliArgs.sessionBackend || cliArgs.backend,
+      backend: cliArgs.backend,
+      sessionBackend: cliArgs.sessionBackend,
       configFile: cliArgs.configFile,
       resumeSessionId: cliArgs.resumeSessionId,
     });
@@ -678,6 +630,7 @@ async function main() {
   let reconnectTaskId = null;
   let pendingRemoteStopEvent = null;
   const pendingRemoteInterruptQueue = createPendingRemoteInterruptQueue();
+  const completedRefreshSessionRequests = new Map();
   let conductor = null;
   let reconnectResumeInFlight = false;
   let fireShuttingDown = false;
@@ -762,6 +715,41 @@ async function main() {
     return await pendingRemoteInterruptQueue.enqueue(event);
   };
 
+  const rememberCompletedRefreshSessionRequest = (requestId, accepted) => {
+    if (!requestId) {
+      return accepted;
+    }
+    completedRefreshSessionRequests.set(requestId, accepted);
+    while (completedRefreshSessionRequests.size > 20) {
+      const oldest = completedRefreshSessionRequests.keys().next();
+      if (oldest.done) {
+        break;
+      }
+      completedRefreshSessionRequests.delete(oldest.value);
+    }
+    return accepted;
+  };
+
+  const handleRefreshSessionCommand = async (event) => {
+    fireWatchdog.onInbound();
+    if (!event || typeof event !== "object") {
+      return false;
+    }
+    const taskId = typeof event.taskId === "string" ? event.taskId : "";
+    const requestId = typeof event.requestId === "string" ? event.requestId.trim() : "";
+    if (reconnectTaskId && taskId && taskId !== reconnectTaskId) {
+      return false;
+    }
+    if (requestId && completedRefreshSessionRequests.has(requestId)) {
+      return completedRefreshSessionRequests.get(requestId) === true;
+    }
+    if (reconnectRunner && typeof reconnectRunner.requestRefreshSessionFromRemote === "function") {
+      const accepted = await reconnectRunner.requestRefreshSessionFromRemote(event);
+      return rememberCompletedRefreshSessionRequest(requestId, accepted !== false);
+    }
+    return rememberCompletedRefreshSessionRequest(requestId, false);
+  };
+
   if (cliArgs.configFile) {
     env.CONDUCTOR_CONFIG = cliArgs.configFile;
   }
@@ -796,7 +784,10 @@ async function main() {
     conductor = await ConductorClient.connect({
       projectPath: runtimeProjectPath,
       extraEnv: env,
-      extraHeaders: buildConductorConnectHeaders(),
+      extraHeaders: buildConductorConnectHeaders(pkgJson.version, {
+        backends: [cliArgs.backend],
+        capabilities: ["refresh_session_inplace"],
+      }),
       configFile: cliArgs.configFile,
       onConnected: (event) => {
         fireWatchdog.onConnected(event);
@@ -813,6 +804,7 @@ async function main() {
       },
       onStopTask: handleStopTaskCommand,
       onInterruptTurn: handleInterruptTurnCommand,
+      onRefreshSession: handleRefreshSessionCommand,
     });
 
     const taskContext = await ensureTaskContext(conductor, {
@@ -852,7 +844,10 @@ async function main() {
       }
     }
 
-    const resolvedResumeSessionId = cliArgs.resumeSessionId;
+    let nextResumeSessionId = cliArgs.resumeSessionId;
+    let nextInitialPrompt =
+      taskContext.shouldProcessInitialPrompt ? cliArgs.initialPrompt : "";
+    let pendingRefreshSessionRequest = null;
 
     const sessionCommandLine = resolveAiSessionCommandLine(
       cliArgs.backend,
@@ -867,19 +862,6 @@ async function main() {
       env: process.env,
     });
 
-    backendSession = createAiSession(cliArgs.sessionBackend || cliArgs.backend, {
-      initialImages: cliArgs.initialImages,
-      cwd: runtimeProjectPath,
-      resumeSessionId: resolvedResumeSessionId,
-      configFile: cliArgs.configFile,
-      ...(cliArgs.sessionOptions || {}),
-      ...(sessionCommandLine ? { commandLine: sessionCommandLine } : {}),
-      logger: { log },
-      ...(resolvedPrePrompt ? { prePrompt: resolvedPrePrompt } : {}),
-      sessionStoreKey: taskContext.taskId ? `task-${taskContext.taskId}` : undefined,
-      resumePersistedSession: Boolean(!resolvedResumeSessionId && taskContext.taskId),
-    });
-
     log(`Using backend: ${cliArgs.backend}`);
 
     try {
@@ -892,26 +874,6 @@ async function main() {
       log(`Failed to report agent resume: ${error?.message || error}`);
     }
 
-    const runner = new BridgeRunner({
-      backendSession,
-      conductor,
-      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,
-      resumeSessionId: resolvedResumeSessionId,
-      daemonName: resolvedDaemonName,
-    });
-    reconnectRunner = runner;
-    if (pendingRemoteStopEvent) {
-      await runner.requestStopFromRemote(pendingRemoteStopEvent);
-      pendingRemoteStopEvent = null;
-    }
-    await pendingRemoteInterruptQueue.flushWith((event) => runner.requestInterruptFromRemote(event));
-
     const signals = new AbortController();
     let shutdownSignal = null;
     let backendShutdownRequested = false;
@@ -955,68 +917,148 @@ async function main() {
       }
     }
 
-    let runnerError = null;
     try {
-      if (!resolvedResumeSessionId && String(cliArgs.sessionBackend || cliArgs.backend).trim().toLowerCase() === "codex") {
-        await withFreshSessionBootstrapLock(cliArgs.sessionBackend || cliArgs.backend, runtimeProjectPath, async () => {
-          await runner.announceBackendSession();
+      while (true) {
+        const currentRefreshSessionRequest = pendingRefreshSessionRequest;
+        let runnerError = null;
+
+        backendSession = createAiSession(cliArgs.sessionBackend || cliArgs.backend, {
+          initialImages: cliArgs.initialImages,
+          cwd: runtimeProjectPath,
+          resumeSessionId: nextResumeSessionId,
+          configFile: cliArgs.configFile,
+          ...(cliArgs.sessionOptions || {}),
+          ...(sessionCommandLine ? { commandLine: sessionCommandLine } : {}),
+          logger: { log },
+          ...(resolvedPrePrompt ? { prePrompt: resolvedPrePrompt } : {}),
+          sessionStoreKey: taskContext.taskId ? `task-${taskContext.taskId}` : undefined,
+          resumePersistedSession: Boolean(!nextResumeSessionId && taskContext.taskId),
         });
-      }
-      await runner.start(signals.signal);
-    } catch (error) {
-      runnerError = error;
-      throw error;
-    } finally {
-      process.off("SIGINT", onSigint);
-      process.off("SIGTERM", onSigterm);
-      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 —
-        // attempting to send a final status update would fail with 500 and the
-        // SDK durable outbox would retry forever, preventing the process from
-        // exiting.
-        const taskDeletedByUser = remoteStopReason === "deleted_by_user";
-        const finalStatus = shutdownSignal
-          ? {
-              status: "KILLED",
-              summary: `terminated by ${shutdownSignal}`,
-            }
-          : runnerError
+
+        const runner = new BridgeRunner({
+          backendSession,
+          conductor,
+          taskId: taskContext.taskId,
+          pollIntervalMs: Math.max(cliArgs.pollIntervalMs, 500),
+          initialPrompt: nextInitialPrompt,
+          initialPromptDelivery: taskContext.initialPromptDelivery || "none",
+          includeInitialImages: Boolean(nextInitialPrompt && cliArgs.initialImages.length),
+          cliArgs: cliArgs.rawBackendArgs,
+          backendName: cliArgs.backend,
+          resumeSessionId: nextResumeSessionId,
+          daemonName: resolvedDaemonName,
+        });
+        reconnectRunner = runner;
+        if (pendingRemoteStopEvent) {
+          await runner.requestStopFromRemote(pendingRemoteStopEvent);
+          pendingRemoteStopEvent = null;
+        }
+        await pendingRemoteInterruptQueue.flushWith((event) => runner.requestInterruptFromRemote(event));
+
+        try {
+          if (currentRefreshSessionRequest) {
+            await runner.announceBackendSession();
+            currentRefreshSessionRequest.resolve(true);
+            pendingRefreshSessionRequest = null;
+          } else if (
+            !nextResumeSessionId &&
+            String(cliArgs.sessionBackend || cliArgs.backend).trim().toLowerCase() === "codex"
+          ) {
+            await withFreshSessionBootstrapLock(
+              cliArgs.sessionBackend || cliArgs.backend,
+              runtimeProjectPath,
+              async () => {
+                await runner.announceBackendSession();
+              },
+            );
+          }
+          await runner.start(signals.signal);
+        } catch (error) {
+          runnerError = error;
+          if (currentRefreshSessionRequest) {
+            currentRefreshSessionRequest.resolve(false);
+            pendingRefreshSessionRequest = null;
+          }
+        }
+
+        const refreshSessionRequest =
+          typeof runner.getRefreshSessionRequest === "function"
+            ? runner.getRefreshSessionRequest()
+            : null;
+        if (!runnerError && !shutdownSignal && refreshSessionRequest) {
+          const refreshedSessionId =
+            refreshSessionRequest.sessionId ||
+            (typeof runner.boundSessionId === "string" ? runner.boundSessionId.trim() : "") ||
+            nextResumeSessionId;
+          if (refreshedSessionId) {
+            nextResumeSessionId = refreshedSessionId;
+            nextInitialPrompt = "";
+            pendingRefreshSessionRequest = refreshSessionRequest;
+            continue;
+          }
+          runnerError = new Error("refresh_session requires a bound session id");
+        }
+        if (refreshSessionRequest && refreshSessionRequest !== pendingRefreshSessionRequest) {
+          refreshSessionRequest.resolve(false);
+        }
+
+        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 —
+          // attempting to send a final status update would fail with 500 and the
+          // SDK durable outbox would retry forever, preventing the process from
+          // exiting.
+          const taskDeletedByUser = remoteStopReason === "deleted_by_user";
+          const finalStatus = shutdownSignal
             ? {
                 status: "KILLED",
-                summary: `conductor fire failed: ${runnerError?.message || runnerError}`,
+                summary: `terminated by ${shutdownSignal}`,
               }
-            : remoteStopSummary
+            : runnerError
               ? {
                   status: "KILLED",
-                  summary: remoteStopSummary,
+                  summary: `conductor fire failed: ${runnerError?.message || runnerError}`,
                 }
-              : {
-                  status: "COMPLETED",
-                  summary: "conductor fire exited",
-                };
-        if (!taskDeletedByUser) {
-          try {
-            const statusResult = await conductor.sendTaskStatus(taskContext.taskId, finalStatus);
-            if (statusResult?.pending && typeof conductor.flushPendingUpstreamEvents === "function") {
-              await conductor.flushPendingUpstreamEvents({
-                timeoutMs: 5_000,
-                retryIntervalMs: 250,
-              });
+              : remoteStopSummary
+                ? {
+                    status: "KILLED",
+                    summary: remoteStopSummary,
+                  }
+                : {
+                    status: "COMPLETED",
+                    summary: "conductor fire exited",
+                  };
+          if (!taskDeletedByUser) {
+            try {
+              const statusResult = await conductor.sendTaskStatus(taskContext.taskId, finalStatus);
+              if (statusResult?.pending && typeof conductor.flushPendingUpstreamEvents === "function") {
+                await conductor.flushPendingUpstreamEvents({
+                  timeoutMs: 5_000,
+                  retryIntervalMs: 250,
+                });
+              }
+            } catch (error) {
+              log(`Failed to report task status (${finalStatus.status}): ${error?.message || error}`);
+            }
+          } else {
+            log(`Skipping final status report: task was deleted by user`);
+            // Also clear any pending durable outbox retries (e.g. task_stop_ack)
+            // that would keep failing against the deleted task.
+            if (typeof conductor.clearDurableOutboxTimer === "function") {
+              conductor.clearDurableOutboxTimer();
             }
-          } catch (error) {
-            log(`Failed to report task status (${finalStatus.status}): ${error?.message || error}`);
-          }
-        } else {
-          log(`Skipping final status report: task was deleted by user`);
-          // Also clear any pending durable outbox retries (e.g. task_stop_ack)
-          // that would keep failing against the deleted task.
-          if (typeof conductor.clearDurableOutboxTimer === "function") {
-            conductor.clearDurableOutboxTimer();
           }
         }
+
+        if (runnerError) {
+          throw runnerError;
+        }
+        break;
       }
+    } finally {
+      process.off("SIGINT", onSigint);
+      process.off("SIGTERM", onSigterm);
       if (shutdownSignal === "SIGINT") {
         process.exitCode = 130;
       } else if (shutdownSignal === "SIGTERM") {
@@ -1242,6 +1284,12 @@ Environment:
   const requestedBackend = conductorArgs.backend
     ? normalizeRuntimeBackendName(conductorArgs.backend)
     : supportedBackends[0] || externalBackends[0];
+  if ((conductorArgs.listBackends || listBackendsWithoutSeparator) && discoveryError) {
+    throw discoveryError;
+  }
+  if (!conductorArgs.backend && discoveryError && isCommandOptionalBuiltInRuntimeBackend(requestedBackend)) {
+    throw discoveryError;
+  }
   const configuredBackend = await resolveConfiguredRuntimeBackend(requestedBackend, allowCliList, {
     configFilePath: configFileFromArgs,
   });
@@ -1266,7 +1314,9 @@ Environment:
   const isAllowedExternalBackend =
     !isBuiltInRuntimeBackend(sessionBackend) &&
     advertisedExternalBackends.has(sessionBackend);
-  if (backend && shouldRequireBackend && !hasConfiguredEntry && !isAllowedExternalBackend) {
+  const isCommandOptionalBuiltInBackend =
+    isCommandOptionalBuiltInRuntimeBackend(sessionBackend || backend);
+  if (backend && shouldRequireBackend && !hasConfiguredEntry && !isAllowedExternalBackend && !isCommandOptionalBuiltInBackend) {
     throw new Error(
       `Unsupported backend "${backend}". Supported backends: ${[...runtimeSupportedBackends].join(", ") || "none configured"}.`,
     );
@@ -1618,6 +1668,7 @@ export async function resolveResumeContext(backend, sessionId, options = {}) {
 
 export async function bootstrapResumeContextForFire({
   backend,
+  sessionBackend,
   configFile,
   resumeSessionId,
   env = process.env,
@@ -1641,7 +1692,8 @@ export async function bootstrapResumeContextForFire({
     return { resumeContext, runtimeProjectPath };
   }
 
-  resumeContext = await resolveResumeContextFn(backend, resumeSessionId, {
+  const resumeLookupBackend = backend || sessionBackend;
+  resumeContext = await resolveResumeContextFn(resumeLookupBackend, resumeSessionId, {
     configFilePath: configFile,
   });
   const sessionLocation = resumeContext.sessionPath ? ` at ${resumeContext.sessionPath}` : "";
@@ -1790,6 +1842,7 @@ export class BridgeRunner {
       os.hostname();
     this.needsReconnectRecovery = false;
     this.remoteStopInfo = null;
+    this.refreshSessionRequest = null;
     this.remoteInterruptsByReplyTo = new Map();
     this.pendingInterruptRetryTimers = new Map();
     this.activeTurnReplyTo = "";
@@ -2009,7 +2062,11 @@ export class BridgeRunner {
   }
 
   shouldSuppressReconnectRecovery() {
-    return this.stopped || Boolean(this.remoteStopInfo);
+    return this.stopped || Boolean(this.remoteStopInfo) || Boolean(this.refreshSessionRequest);
+  }
+
+  getRefreshSessionRequest() {
+    return this.refreshSessionRequest;
   }
 
   getRemoteStopReason() {
@@ -2052,6 +2109,54 @@ export class BridgeRunner {
     }
   }
 
+  async requestRefreshSessionFromRemote(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 sessionId = typeof event.sessionId === "string" ? event.sessionId.trim() : "";
+    const sessionFilePath =
+      typeof event.sessionFilePath === "string" && event.sessionFilePath.trim()
+        ? event.sessionFilePath.trim()
+        : "";
+    if (!sessionId) {
+      return false;
+    }
+    if (this.refreshSessionRequest) {
+      if (
+        requestId &&
+        this.refreshSessionRequest.requestId &&
+        this.refreshSessionRequest.requestId === requestId
+      ) {
+        return await this.refreshSessionRequest.promise;
+      }
+      return false;
+    }
+
+    let resolveRefresh;
+    const promise = new Promise((resolve) => {
+      resolveRefresh = resolve;
+    });
+    this.refreshSessionRequest = {
+      requestId: requestId || null,
+      sessionId,
+      sessionFilePath: sessionFilePath || null,
+      promise,
+      resolve: resolveRefresh,
+    };
+    log(`Received refresh_session for ${this.taskId}; rebuilding backend session in-process`);
+    this.stopped = true;
+    if (typeof this.backendSession?.close === "function") {
+      try {
+        await this.backendSession.close();
+      } catch (error) {
+        log(`Failed to close backend session for refresh ${this.taskId}: ${error?.message || error}`);
+      }
+    }
+    return await promise;
+  }
+
   normalizeReplyTarget(replyTo) {
     return typeof replyTo === "string" ? replyTo.trim() : "";
   }