@yeaft/webchat-agent 1.0.43 → 1.0.45

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.45",
   "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;
 }
 

package/yeaft/web-bridge.js

@@ -164,6 +164,41 @@ async function sendDreamSnapshotForSession(sessionId, extra = {}) {
   return snapshot;
 }
 
+function scheduleYeaftLoadHistoryMetadataReplay(sessionId) {
+  const replaySession = session;
+  const replayConversationId = yeaftConversationId;
+  setTimeout(() => {
+    try {
+      if (!replaySession) return;
+      refreshLiveSessionConfig();
+      hydrateYeaftStatusFromSession(replaySession, { reason: 'history_load', emitEvent: true });
+      sendSessionEvent({
+        type: 'session_ready',
+        conversationId: replayConversationId,
+        model: replaySession.config.primaryModel || replaySession.config.model,
+        modelEffort: replaySession.config.modelEffort || null,
+        availableModels: replaySession.config.availableModels || [],
+        skills: replaySession.status.skills,
+        mcpServers: replaySession.status.mcpServers,
+        tools: replaySession.status.tools,
+        yeaftDir: ctx.CONFIG?.yeaftDir || null,
+        tasks: replaySession.taskManager ? replaySession.taskManager.listActiveTasks() : [],
+      });
+      sendSessionSnapshotBroadcast();
+      if (sessionId && session === replaySession) {
+        sendDreamSnapshotForSession(sessionId, { trigger: 'load_history' }).catch(() => null);
+      }
+      try {
+        getVpStatusBroker().broadcastSnapshot();
+      } catch (err) {
+        console.warn('[Yeaft] vp-status snapshot broadcast (replay) failed:', err?.message || err);
+      }
+    } catch (err) {
+      console.warn('[Yeaft] load-history metadata replay failed:', err?.message || err);
+    }
+  }, 0);
+}
+
 
 /**
  * Single in-flight AbortController for legacy 1:1 chat. A new 1:1 user message
@@ -4819,6 +4854,7 @@ export function handleYeaftModelSwitch(msg) {
  */
 export async function handleYeaftLoadHistory(msg) {
   const sessionId = (msg && typeof msg.sessionId === 'string' && msg.sessionId) || null;
+  const metadataOnly = msg && Number.isFinite(msg.limit) && msg.limit <= 0;
   // `lim` is now expressed in TURNS, not raw messages. `loadRecent` and
   // `loadRecentBySession` use turn-based slicing so the cut never lands
   // mid-tool-arc. Pass `undefined` to use the persistence-layer default
@@ -4828,6 +4864,7 @@ export async function handleYeaftLoadHistory(msg) {
   let historyAlreadyReplayed = false;
 
   const replayHistoryFromStore = () => {
+    if (metadataOnly) return;
     // Delta path: caller knows the latest seq (or message id) it has cached
     // and wants only the messages that arrived after that cursor. Returns
     // mode:'delta' so the frontend can append+dedupe instead of replacing
@@ -4959,7 +4996,7 @@ export async function handleYeaftLoadHistory(msg) {
         afterSeq,
       });
       sendSessionEvent({ type: 'history_loaded', mode: 'delta', count: projectedMessages.length, sessionId, latestSeq: delta.latestSeq, afterSeq });
-    } else {
+    } else if (!metadataOnly) {
       emitVisibleHistoryReplay({ store: coldStore, sessionId, limit, mode: 'recent' });
     }
     historyAlreadyReplayed = true;
@@ -4972,9 +5009,6 @@ export async function handleYeaftLoadHistory(msg) {
     });
     installYeaftRuntimeBridge(session);
 
-    refreshLiveSessionConfig();
-    hydrateYeaftStatusFromSession(session, { reason: 'history_load', emitEvent: true });
-
     // Per-group history hydrates lazily via getOrCreateSessionHistory.
     // When the load-history call carries a sessionId, force-refresh THAT
     // group's tape so the next user message sees on-disk state. When
@@ -4984,8 +5018,6 @@ export async function handleYeaftLoadHistory(msg) {
   } else {
     replayHistoryFromStore();
     historyAlreadyReplayed = true;
-    refreshLiveSessionConfig();
-    hydrateYeaftStatusFromSession(session, { reason: 'history_load', emitEvent: true });
   }
 
   if (sessionId) {
@@ -4995,31 +5027,11 @@ export async function handleYeaftLoadHistory(msg) {
     setGroupHistory(sessionId, hydrateGroupHistory(sessionId));
   }
 
-  // Always replay session_ready so refresh / reconnect rebuilds UI state.
-  sendSessionEvent({
-    type: 'session_ready',
-    conversationId: yeaftConversationId,
-    model: session.config.primaryModel || session.config.model,
-    modelEffort: session.config.modelEffort || null,
-    availableModels: session.config.availableModels || [],
-    skills: session.status.skills,
-    mcpServers: session.status.mcpServers,
-    tools: session.status.tools,
-    yeaftDir: ctx.CONFIG?.yeaftDir || null,
-    tasks: session.taskManager ? session.taskManager.listActiveTasks() : [],
-  });
-  sendSessionSnapshotBroadcast();
-  if (sessionId) {
-    await sendDreamSnapshotForSession(sessionId, { trigger: 'load_history' }).catch(() => null);
-  }
-  // vp-status: replay the authoritative table on reconnect so a refreshed
-  // frontend doesn't have to wait for the next transition to learn each
-  // VP's current state.
-  try {
-    getVpStatusBroker().broadcastSnapshot();
-  } catch (err) {
-    console.warn('[Yeaft] vp-status snapshot broadcast (replay) failed:', err?.message || err);
-  }
+  // Always replay session_ready so refresh / reconnect rebuilds UI state, but
+  // never make the history response wait for bulky metadata snapshots. The
+  // first visible chunk has already been sent above; defer metadata to the next
+  // tick so the browser can paint messages before VP/session/dream snapshots.
+  scheduleYeaftLoadHistoryMetadataReplay(sessionId);
 
   if (historyAlreadyReplayed) return;