@yeaft/webchat-agent 1.0.43 → 1.0.44

package/conversation.js

@@ -369,6 +369,11 @@ export async function createConversation(msg) {
     });
   } else {
     // Non-Claude providers own their own state construction.
+    // deferBoot: don't block conversation_created on the provider's slow boot
+    // (Copilot's ACP handshake spawns a CLI and can take tens of seconds). The
+    // sidebar row must appear immediately; boot runs in the background and the
+    // first sendInput joins the same in-flight boot. Mirrors the Claude path,
+    // which prestarts in the background below.
     const driver = getProvider(provider);
     const state = await driver.start({
       conversationId,
@@ -377,6 +382,7 @@ export async function createConversation(msg) {
       userId,
       username,
       providerOptions: msg.providerOptions || {},
+      deferBoot: true,
     });
     state.disallowedTools = disallowedTools || null;
   }
@@ -495,6 +501,9 @@ export async function resumeConversation(msg) {
   // Non-Claude providers: re-init state via driver so sessionId/providerName are set correctly.
   if (provider !== 'claude-code') {
     const driver = getProvider(provider);
+    // deferBoot: same reasoning as createConversation — emit conversation_resumed
+    // immediately so the row shows, and boot the provider session in the
+    // background instead of blocking restore on the ACP handshake.
     const state = await driver.start({
       conversationId,
       workDir: effectiveWorkDir,
@@ -502,6 +511,7 @@ export async function resumeConversation(msg) {
       userId,
       username,
       providerOptions: msg.providerOptions || priorProviderOptions || {},
+      deferBoot: true,
     });
     state.disallowedTools = disallowedTools || null;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.43",
+  "version": "1.0.44",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",

package/providers/acp-client.js

@@ -38,17 +38,36 @@ export class AcpClient {
     stdout.on('close', () => this._handleClose());
   }
 
-  /** Send a JSONRPC request and await its response. */
-  request(method, params) {
+  /**
+   * Send a JSONRPC request and await its response.
+   * @param {string} method
+   * @param {any} params
+   * @param {object} [opts]
+   * @param {number} [opts.timeoutMs]  reject if no response arrives within this
+   *   window. Omit for no timeout (e.g. session/prompt, which can legitimately
+   *   run for minutes). Use it on the boot handshake so a wedged CLI surfaces an
+   *   error instead of hanging the session forever.
+   */
+  request(method, params, opts = {}) {
     if (this._closed) return Promise.reject(new Error('acp client closed'));
     const id = this._nextId++;
     const payload = { jsonrpc: '2.0', id, method, params };
     return new Promise((resolve, reject) => {
-      this._pending.set(id, { resolve, reject });
+      let timer = null;
+      if (opts.timeoutMs > 0) {
+        timer = setTimeout(() => {
+          if (!this._pending.has(id)) return;
+          this._pending.delete(id);
+          reject(new Error(`acp request '${method}' timed out after ${opts.timeoutMs}ms`));
+        }, opts.timeoutMs);
+        if (typeof timer.unref === 'function') timer.unref();
+      }
+      this._pending.set(id, { resolve, reject, timer });
       try {
         this._stdin.write(JSON.stringify(payload) + '\n');
       } catch (err) {
         this._pending.delete(id);
+        if (timer) clearTimeout(timer);
         reject(err);
       }
     });
@@ -67,7 +86,8 @@ export class AcpClient {
     if (this._closed) return;
     this._closed = true;
     const err = new Error(reason || 'acp client closed');
-    for (const { reject } of this._pending.values()) {
+    for (const { reject, timer } of this._pending.values()) {
+      if (timer) clearTimeout(timer);
       try { reject(err); } catch { /* noop */ }
     }
     this._pending.clear();
@@ -97,6 +117,7 @@ export class AcpClient {
       const slot = this._pending.get(msg.id);
       if (!slot) return; // stale
       this._pending.delete(msg.id);
+      if (slot.timer) clearTimeout(slot.timer);
       if (msg.error) slot.reject(Object.assign(new Error(msg.error.message || 'acp error'), { code: msg.error.code, data: msg.error.data }));
       else slot.resolve(msg.result);
       return;

package/providers/copilot.js

@@ -25,6 +25,11 @@ const COPILOT_BIN = process.env.COPILOT_BIN || 'copilot';
 // YOLO is now opt-in only; per-conv allowAllTools is the normal channel.
 const YOLO = process.env.COPILOT_YOLO === '1';
 const ACP_PROTOCOL_VERSION = 1;
+// Boot handshake (initialize / session/new / session/load) timeout. A wedged or
+// mis-installed CLI would otherwise leave the request pending forever — and with
+// deferred boot that means a session that never finishes connecting. session/prompt
+// is deliberately NOT bounded: a turn can legitimately run for minutes.
+const BOOT_REQUEST_TIMEOUT_MS = 120_000;
 
 export function resolveCopilotLaunchOptions({ cwd, env = process.env, platform = osPlatform(), bin = COPILOT_BIN } = {}) {
   const isWindows = platform === 'win32';
@@ -78,27 +83,80 @@ export async function start(opts) {
     allowAllTools,
     capabilities,
     initialized: false,
+    _bootPromise: null,  // in-flight _bootAcp() promise; coalesces concurrent boots
     pendingPermissions: new Map(),  // requestId → { resolve, reject } for ask-user round-trip
     usage: { inputTokens: 0, outputTokens: 0, cacheRead: 0, cacheCreation: 0, totalCostUsd: 0 },
   };
   ctx.conversations.set(conversationId, state);
 
-  // Best-effort start; failures emit a result envelope and leave state in place
-  // so the next sendInput retries.
+  const resumeSessionId = opts.resumeSessionId || null;
+
+  // deferBoot: return immediately without awaiting the ACP handshake. The slow
+  // part — spawn `copilot --acp` → initialize → session/new — would otherwise
+  // block the caller (session create/resume) from emitting conversation_created,
+  // so the sidebar row only appears after the whole handshake (~tens of seconds
+  // on a cold CLI). With deferBoot the row shows instantly and the boot runs in
+  // the background; the first sendInput joins the same in-flight boot via
+  // _ensureBooted instead of spawning a second child.
+  if (opts.deferBoot) {
+    _ensureBooted(state, resumeSessionId).catch((err) => {
+      // _emitBootError writes to the WebSocket; if that itself throws (server
+      // gone) there's nothing more to do — don't turn it into an unhandled rejection.
+      try { _emitBootError(state, err); } catch { /* noop */ }
+    });
+    return state;
+  }
+
+  // Foreground boot (self-heal paths that must have a live session before
+  // dispatching the very next action). Best-effort; failures emit a result
+  // envelope and leave state in place so the next sendInput retries.
   try {
-    await _bootAcp(state, opts.resumeSessionId || null);
+    await _ensureBooted(state, resumeSessionId);
   } catch (err) {
-    sendOutput(conversationId, {
-      type: 'result',
-      subtype: 'error',
-      session_id: state.sessionId,
-      is_error: true,
-      error: `copilot ACP init failed: ${err?.message || err}. Run \`copilot login\` and ensure CLI >= 1.0.59.`,
-    });
+    _emitBootError(state, err);
   }
   return state;
 }
 
+function _emitBootError(state, err) {
+  sendOutput(state.conversationId, {
+    type: 'result',
+    subtype: 'error',
+    session_id: state.sessionId,
+    is_error: true,
+    error: `copilot ACP init failed: ${err?.message || err}. Run \`copilot login\` and ensure CLI >= 1.0.59.`,
+  });
+}
+
+/**
+ * Ensure the ACP child + session are up, coalescing concurrent callers onto a
+ * single in-flight boot. A backgrounded start() (deferBoot) and an early
+ * sendInput therefore share ONE boot instead of spawning two children. Throws
+ * if the boot fails; the in-flight promise is cleared either way so the next
+ * call retries from scratch.
+ */
+async function _ensureBooted(state, resumeSessionId) {
+  // Readiness requires a sessionId too, not just `initialized`. `initialized`
+  // flips true right after the `initialize` response but BEFORE session/new
+  // establishes state.sessionId — a message arriving in that window would
+  // otherwise prompt with sessionId:null and lose the turn. Gating on sessionId
+  // keeps callers coalesced onto the in-flight boot until the session exists.
+  if (state.initialized && state.acpClient && state.sessionId) return;
+  if (state._bootPromise) return state._bootPromise;
+  const p = (async () => {
+    try {
+      await _bootAcp(state, resumeSessionId);
+    } finally {
+      // Only clear if we're still the current boot — a crash-close (which nulls
+      // _bootPromise) followed by a fresh boot must not have its promise wiped
+      // by this stale finally.
+      if (state._bootPromise === p) state._bootPromise = null;
+    }
+  })();
+  state._bootPromise = p;
+  return p;
+}
+
 async function _bootAcp(state, resumeSessionId) {
   const args = ['--acp'];
   if (Array.isArray(state.providerOptions?.addDirs)) {
@@ -125,6 +183,10 @@ async function _bootAcp(state, resumeSessionId) {
     if (client) client.close(message);
   });
   child.on('close', (code) => {
+    // Ignore a late close from a child that's already been replaced (e.g. a
+    // reboot spawned a new one) or torn down — otherwise this would clobber the
+    // live boot's acpClient/_bootPromise and orphan the new child.
+    if (state.copilotChild !== child) return;
     if (state.turnActive) {
       const tail = stderrBuf.trim().slice(-2000);
       _sendTurnError(state, tail || `copilot exited mid-turn (code ${code})`);
@@ -139,6 +201,7 @@ async function _bootAcp(state, resumeSessionId) {
     state.copilotChild = null;
     state.acpClient = null;
     state.initialized = false;
+    state._bootPromise = null;
   });
 
   client = new AcpClient({
@@ -160,7 +223,7 @@ async function _bootAcp(state, resumeSessionId) {
   const initResp = await client.request('initialize', {
     protocolVersion: ACP_PROTOCOL_VERSION,
     clientCapabilities: {},
-  });
+  }, { timeoutMs: BOOT_REQUEST_TIMEOUT_MS });
   state.acpCapabilities = initResp?.agentCapabilities || {};
   state.initialized = true;
 
@@ -170,7 +233,7 @@ async function _bootAcp(state, resumeSessionId) {
       sessionId: resumeSessionId,
       cwd: state.workDir,
       mcpServers: [],
-    });
+    }, { timeoutMs: BOOT_REQUEST_TIMEOUT_MS });
     state.sessionId = resumeSessionId;
     state.claudeSessionId = resumeSessionId;
     if (Array.isArray(r?.modes?.availableModes)) state.acpModes = r.modes.availableModes;
@@ -189,7 +252,7 @@ async function _bootAcp(state, resumeSessionId) {
     const r = await client.request('session/new', {
       cwd: state.workDir,
       mcpServers: [],
-    });
+    }, { timeoutMs: BOOT_REQUEST_TIMEOUT_MS });
     state.sessionId = r?.sessionId || randomUUID();
     state.claudeSessionId = state.sessionId;
     if (Array.isArray(r?.modes?.availableModes)) state.acpModes = r.modes.availableModes;
@@ -217,9 +280,13 @@ export async function sendInput(state, prompt, opts = {}) {
   if (!conversationId) throw new Error('copilot: conversationId required');
 
   // Ensure ACP child + session are up; reboot if a prior crash dropped them.
-  if (!state.initialized || !state.acpClient) {
+  // _ensureBooted coalesces onto a backgrounded deferBoot still in flight, so a
+  // fast first message doesn't spawn a second child. Gate on sessionId too: a
+  // message can land after `initialize` but before session/new, when initialized
+  // is already true but sessionId is still null.
+  if (!state.initialized || !state.acpClient || !state.sessionId) {
     try {
-      await _bootAcp(state, state.sessionId || null);
+      await _ensureBooted(state, state.sessionId || null);
     } catch (err) {
       _sendTurnError(state, `copilot ACP reinit failed: ${err?.message || err}`);
       _completeTurn(state, conversationId);
@@ -323,6 +390,7 @@ export function dispose(state, reason = 'disposed') {
     state.copilotChild = null;
   }
   state.initialized = false;
+  state._bootPromise = null;
   state.turnActive = false;
 }