@yemi33/minions 0.1.2383 → 0.1.2385

package/engine/acp-transport.js

@@ -93,6 +93,10 @@ function typedError(message, code, retriable = true) {
 // consumers that pre-warm (like cc-worker-pool.js's warmTab) can share the
 // same knob instead of hardcoding their own copy.
 const WARM_MAX_CONCURRENT = 3;
+const ACP_HANDSHAKE_TIMEOUT_MS = 60000;
+const SESSION_LOAD_RETRY_ATTEMPTS = 10;
+const SESSION_LOAD_RETRY_DELAY_MS = 100;
+const SESSION_ROTATION_CANCEL_WAIT_MS = 1000;
 
 function resolveWorkerRuntime(runtime) {
   const adapter = typeof runtime === 'string'
@@ -106,7 +110,7 @@ function resolveWorkerRuntime(runtime) {
 
 // Real spawn implementation. Binary resolution and worker argv are both
 // adapter-owned so harness CLI flag changes do not leak into the transport.
-function spawnAcp({ runtime, cwd, env } = {}) {
+function spawnAcp({ runtime, cwd, env, workerOptions } = {}) {
   const adapter = resolveWorkerRuntime(runtime);
   const workerEnv = env || process.env;
   const resolved = adapter.resolveBinary({ env: workerEnv });
@@ -116,7 +120,10 @@ function spawnAcp({ runtime, cwd, env } = {}) {
     );
   }
   const { bin, native, leadingArgs = [] } = resolved;
-  const acpArgs = [...leadingArgs, ...buildWorkerArgs(adapter, { cwd, env: workerEnv })];
+  const acpArgs = [
+    ...leadingArgs,
+    ...buildWorkerArgs(adapter, { ...(workerOptions || {}), cwd, env: workerEnv }),
+  ];
   // Mirror engine/spawn-agent.js: native binaries run directly; a non-native
   // (JS entry / npm shim) runs under process.execPath as `node <bin> ...`.
   const execBin = native ? bin : process.execPath;
@@ -143,6 +150,10 @@ function killImmediate(proc) {
   }
 }
 
+function killRoot(proc) {
+  try { proc.kill('SIGKILL'); } catch { /* already dead */ }
+}
+
 function hashMcpServers(mcpServers) {
   // Stable hash via JSON.stringify; mcpServers is an array of plain objects
   // in practice (name/command/env) so the natural key order is fine.
@@ -150,18 +161,31 @@ function hashMcpServers(mcpServers) {
   return crypto.createHash('sha256').update(json).digest('hex');
 }
 
-function _stableObject(value) {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return {};
+function _stableValue(value) {
+  if (Array.isArray(value)) return value.map(_stableValue);
+  if (!value || typeof value !== 'object') return value;
   return Object.fromEntries(
     Object.entries(value)
       .filter(([, entry]) => entry !== undefined)
       .sort(([a], [b]) => a.localeCompare(b))
+      .map(([key, entry]) => [key, _stableValue(entry)])
   );
 }
 
-function hashProcessContext(processEnv) {
+function _stableObject(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return {};
+  return _stableValue(value);
+}
+
+function hashProcessContext(processEnv, processOptions) {
+  const context = processOptions === undefined
+    ? _stableObject(processEnv)
+    : {
+      env: _stableObject(processEnv),
+      options: _stableValue(processOptions),
+    };
   return crypto.createHash('sha256')
-    .update(JSON.stringify(_stableObject(processEnv)))
+    .update(JSON.stringify(context))
     .digest('hex');
 }
 
@@ -203,6 +227,10 @@ function extractSessionModel(result) {
   return null;
 }
 
+function buildSessionLoadParams({ sessionId, cwd, mcpServers }) {
+  return { sessionId, cwd, mcpServers: mcpServers || [] };
+}
+
 function extractChunkText(content) {
   if (content == null) return '';
   if (typeof content === 'string') return content;
@@ -270,7 +298,7 @@ class Worker {
   constructor({
     runtime,
     id, model, effort, mcpServers, mcpServersHash, processEnv, processContextHash,
-    systemPromptHash, cwd, internals, trace,
+    workerOptions, resumeSessionId, systemPromptHash, cwd, processCwd, internals, trace,
   }) {
     this.runtime = resolveWorkerRuntime(runtime);
     this.id = id;
@@ -280,12 +308,16 @@ class Worker {
     this.mcpServersHash = mcpServersHash;
     this.processEnv = processEnv;
     this.processContextHash = processContextHash;
+    this.workerOptions = workerOptions && typeof workerOptions === 'object' ? { ...workerOptions } : {};
+    this.resumeSessionId = resumeSessionId || null;
     this.systemPromptHash = systemPromptHash;
     this.cwd = cwd || process.cwd();
+    this.processCwd = processCwd || this.cwd;
     this._internals = internals;
     this._trace = typeof trace === 'function' ? trace : () => {};
 
     this.proc = null;
+    this.processStartedAt = 0;
     this.sessionId = null;
     this.pending = new Map();      // id → { resolve, reject }
     this.inflight = null;          // current { id, sessionId, onChunk, onDone, onError, signal, signalHandler, settled }
@@ -295,6 +327,7 @@ class Worker {
     this.killed = false;
     this.spawnError = null;
     this.firstSystemPromptSent = false;
+    this.preservedDescendantPids = new Set();
     // In-flight spawn+initialize+session/new promise. Set by the consumer
     // before the worker is registered in its own pool bookkeeping, cleared
     // after the handshake settles. Racing callers await this to avoid the
@@ -307,7 +340,12 @@ class Worker {
   async _spawnAndInit() {
     let proc;
     try {
-      proc = this._internals.spawnAcp({ runtime: this.runtime, cwd: this.cwd, env: this.processEnv });
+      proc = this._internals.spawnAcp({
+        runtime: this.runtime,
+        cwd: this.processCwd,
+        env: this.processEnv,
+        workerOptions: this.workerOptions,
+      });
     } catch (err) {
       const hint = this.runtime.workerErrorHint || `${this.runtime.name} persistent worker failed`;
       throw typedError(
@@ -359,30 +397,63 @@ class Worker {
     };
     proc.on('error', errorHandler);
 
+    const configuredHandshakeTimeout = Number(this._internals.handshakeTimeoutMs);
+    const handshakeTimeoutMs = Number.isFinite(configuredHandshakeTimeout) && configuredHandshakeTimeout > 0
+      ? configuredHandshakeTimeout
+      : ACP_HANDSHAKE_TIMEOUT_MS;
+    let handshakeTimer;
+    const handshakeTimeoutPromise = new Promise((_, reject) => {
+      handshakeTimer = setTimeout(() => {
+        reject(typedError(
+          `copilot --acp handshake timed out after ${handshakeTimeoutMs}ms`,
+          ERROR_CODES.ACP_HANDSHAKE_FAILED,
+          true
+        ));
+      }, handshakeTimeoutMs);
+    });
+
     try {
       await Promise.race([
         this._call('initialize', { protocolVersion: 1, clientCapabilities: {} }),
         earlyExitPromise,
+        handshakeTimeoutPromise,
       ]);
+      const sessionMethod = this.resumeSessionId ? 'session/load' : 'session/new';
+      const sessionParams = this.resumeSessionId
+        ? buildSessionLoadParams({
+          sessionId: this.resumeSessionId,
+          cwd: this.cwd,
+          mcpServers: this.mcpServers,
+        })
+        : buildSessionNewParams({
+          cwd: this.cwd,
+          mcpServers: this.mcpServers,
+          model: this.model,
+          effort: this.effort,
+        });
+      const sessionPromise = sessionMethod === 'session/load'
+        ? this._loadSession(sessionParams)
+        : this._call(sessionMethod, sessionParams);
       const result = await Promise.race([
-        this._call('session/new', buildSessionNewParams({
-          cwd: this.cwd, mcpServers: this.mcpServers, model: this.model, effort: this.effort,
-        })),
+        sessionPromise,
         earlyExitPromise,
+        handshakeTimeoutPromise,
       ]);
-      this.sessionId = result && result.sessionId;
+      this.sessionId = (result && result.sessionId) || this.resumeSessionId;
       this.currentModel = extractSessionModel(result) || normalizeExecutionModel(this.model);
       if (!this.sessionId) {
         // Handshake completed without an error but the daemon didn't hand
         // back a sessionId — protocol violation or partial init failure.
         const hint = this.runtime.workerErrorHint || `${this.runtime.name} persistent worker failed`;
         throw typedError(
-          `${hint} (session/new returned no sessionId)`,
+          `${hint} (${sessionMethod} returned no sessionId)`,
           ERROR_CODES.ACP_HANDSHAKE_FAILED,
           true
         );
       }
+      this.firstSystemPromptSent = !!this.resumeSessionId;
     } finally {
+      clearTimeout(handshakeTimer);
       // Either the handshake finished (swap to a persistent exit handler that
       // just marks killed) or it failed (proc is dying anyway).
       proc.removeListener('exit', earlyExitHandler);
@@ -431,9 +502,13 @@ class Worker {
   _handleMessage(obj) {
     // Response (matches an outbound id)
     if (obj.id != null && this.pending.has(obj.id)) {
-      const { resolve, reject } = this.pending.get(obj.id);
+      const { resolve, reject, method } = this.pending.get(obj.id);
       this.pending.delete(obj.id);
-      if (obj.error) reject(new Error(obj.error.message || 'ACP error'));
+      if (obj.error) {
+        const err = new Error(obj.error.message || 'ACP error');
+        err.acpMethod = method || null;
+        reject(err);
+      }
       else resolve(obj.result);
       return;
     }
@@ -483,10 +558,35 @@ class Worker {
     catch { /* pipe may be broken; exit handler will fire */ }
   }
 
-  _call(method, params) {
+  _call(method, params, timeoutMs) {
+    if (this.killed || !this.proc?.stdin || this.proc.stdin.destroyed) {
+      return Promise.reject(new Error('acp-transport: worker is closed'));
+    }
     return new Promise((resolve, reject) => {
       const id = this.nextReqId++;
-      this.pending.set(id, { resolve, reject });
+      let timer;
+      const settle = (callback, value) => {
+        if (timer) clearTimeout(timer);
+        callback(value);
+      };
+      this.pending.set(id, {
+        resolve: (value) => settle(resolve, value),
+        reject: (err) => settle(reject, err),
+        method,
+      });
+      const parsedTimeout = Number(timeoutMs);
+      if (Number.isFinite(parsedTimeout) && parsedTimeout > 0) {
+        timer = setTimeout(() => {
+          if (!this.pending.delete(id)) return;
+          const err = typedError(
+            `acp-transport: ${method} timed out after ${parsedTimeout}ms`,
+            ERROR_CODES.ACP_HANDSHAKE_FAILED,
+            true
+          );
+          err.acpMethod = method;
+          reject(err);
+        }, parsedTimeout);
+      }
       this._writeFrame({ jsonrpc: '2.0', id, method, params });
     });
   }
@@ -495,6 +595,20 @@ class Worker {
     this._writeFrame({ jsonrpc: '2.0', method, params });
   }
 
+  async _loadSession(params) {
+    let lastError;
+    for (let attempt = 0; attempt < SESSION_LOAD_RETRY_ATTEMPTS; attempt++) {
+      try {
+        return await this._call('session/load', params, ACP_HANDSHAKE_TIMEOUT_MS);
+      } catch (err) {
+        lastError = err;
+        if (!/already loaded/i.test(String(err && err.message))) throw err;
+        await new Promise((resolve) => setTimeout(resolve, SESSION_LOAD_RETRY_DELAY_MS));
+      }
+    }
+    throw lastError;
+  }
+
   // ── Stream a single turn ───────────────────────────────────────────────
   stream(promptText, opts = {}) {
     const {
@@ -519,8 +633,11 @@ class Worker {
     // message remains correct.
     let prompt = promptText;
     const trustedContextText = buildTrustedSessionContext(trustedSessionContext);
-    const trustedSystemText = [systemPromptText, trustedContextText].filter(Boolean).join('\n\n');
-    if (!this.firstSystemPromptSent && trustedSystemText) {
+    const trustedSystemText = [
+      !this.firstSystemPromptSent ? systemPromptText : null,
+      trustedContextText,
+    ].filter(Boolean).join('\n\n');
+    if (trustedSystemText) {
       prompt = `<system>\n${trustedSystemText}\n</system>\n\n${promptText}`;
     }
     if (!deferSystemPrompt) this.firstSystemPromptSent = true;
@@ -586,8 +703,8 @@ class Worker {
     this._notify('session/cancel', { sessionId: this.inflight.sessionId });
   }
 
-  async newSession(options = {}) {
-    const { mcpServers, systemPromptHash, model, effort, cwd } = options;
+  async _prepareSession(options = {}) {
+    const { sessionId, mcpServers, systemPromptHash, model, effort, cwd } = options;
     // Cancel any inflight before swapping the underlying session.
     if (this.inflight) {
       this.cancel();
@@ -597,11 +714,15 @@ class Worker {
       await new Promise((resolve) => {
         const start = this._internals.now();
         const wait = () => {
-          if (!inflight || inflight.settled || this._internals.now() - start > 1000) resolve();
+          if (!inflight || inflight.settled
+              || this._internals.now() - start > SESSION_ROTATION_CANCEL_WAIT_MS) resolve();
           else setTimeout(wait, 5);
         };
         wait();
       });
+      if (!inflight.settled) {
+        throw new Error('acp-transport: cancelled prompt did not settle before session rotation');
+      }
     }
     // Bug B (issue #2479): if the caller is rotating the session because the
     // system prompt changed, they may also be passing a fresh model/effort —
@@ -613,14 +734,71 @@ class Worker {
     // agent-worker-pool.js reuses a warm worker across dispatches with
     // different cwds (unlike cc-worker-pool.js, whose tabs never change
     // cwd) — allow the caller to rotate it in on a session swap.
-    if (cwd !== undefined && cwd !== null && cwd !== '') this.cwd = cwd;
-    const result = await this._call('session/new', buildSessionNewParams({
-      cwd: this.cwd, mcpServers: mcpServers || [], model: this.model, effort: this.effort,
-    }));
-    this.sessionId = result && result.sessionId;
+    const nextCwd = cwd !== undefined && cwd !== null && cwd !== '' ? cwd : this.cwd;
+    if (sessionId && this.sessionId === sessionId) {
+      if (nextCwd !== this.cwd) {
+        const err = new Error('acp-transport: loaded session cannot change cwd without a worker respawn');
+        err.acpMethod = 'session/load';
+        throw err;
+      }
+      this.systemPromptHash = systemPromptHash;
+      this.firstSystemPromptSent = true;
+      return;
+    }
+    this.cwd = nextCwd;
+    const method = sessionId ? 'session/load' : 'session/new';
+    const params = sessionId
+      ? buildSessionLoadParams({ sessionId, cwd: this.cwd, mcpServers: mcpServers || [] })
+      : buildSessionNewParams({
+        cwd: this.cwd,
+        mcpServers: mcpServers || [],
+        model: this.model,
+        effort: this.effort,
+      });
+    const result = method === 'session/load'
+      ? await this._loadSession(params)
+      : await this._call(method, params, ACP_HANDSHAKE_TIMEOUT_MS);
+    this.sessionId = (result && result.sessionId) || sessionId;
+    if (!this.sessionId) {
+      const hint = this.runtime.workerErrorHint || `${this.runtime.name} persistent worker failed`;
+      throw typedError(
+        `${hint} (${method} returned no sessionId)`,
+        ERROR_CODES.ACP_HANDSHAKE_FAILED,
+        true
+      );
+    }
     this.currentModel = extractSessionModel(result) || normalizeExecutionModel(this.model);
     this.systemPromptHash = systemPromptHash;
-    this.firstSystemPromptSent = false;
+    this.firstSystemPromptSent = !!sessionId;
+  }
+
+  async newSession(opts) {
+    return this._prepareSession({ ...opts, sessionId: null });
+  }
+
+  async loadSession(sessionId, opts) {
+    return this._prepareSession({ ...opts, sessionId });
+  }
+
+  preserveDescendants(pids) {
+    for (const pid of pids || []) {
+      const value = Number(pid);
+      if (Number.isInteger(value) && value > 0) this.preservedDescendantPids.add(value);
+    }
+  }
+
+  abandon() {
+    if (this.killed) return;
+    this.killed = true;
+    try { this.proc?.stdin?.end(); } catch { /* pipe already closed */ }
+    const err = new Error('acp-transport: unverified worker abandoned');
+    this._failAllPending(err);
+    if (this.inflight && !this.inflight.settled) {
+      const cb = this.inflight.onError;
+      this.inflight.settled = true;
+      this.inflight = null;
+      if (cb) try { cb(err); } catch { /* swallow */ }
+    }
   }
 
   close() {
@@ -633,7 +811,13 @@ class Worker {
       catch { /* swallow */ }
     }
     if (this.proc) {
-      try { this._internals.killImmediate(this.proc); } catch { /* already dead */ }
+      try {
+        if (this.preservedDescendantPids.size > 0 && typeof this._internals.killRoot === 'function') {
+          this._internals.killRoot(this.proc);
+        } else {
+          this._internals.killImmediate(this.proc);
+        }
+      } catch { /* already dead */ }
     }
     this._failAllPending(new Error('acp-transport: worker closed'));
     if (this.inflight && !this.inflight.settled) {
@@ -651,13 +835,16 @@ module.exports = {
   spawnAcp,
   resolveWorkerRuntime,
   killImmediate,
+  killRoot,
   hashMcpServers,
   hashProcessContext,
   buildTrustedSessionContext,
   buildSessionNewParams,
   extractSessionModel,
+  buildSessionLoadParams,
   extractChunkText,
   mapAcpToolCallToToolUse,
   Worker,
   WARM_MAX_CONCURRENT,
+  ACP_HANDSHAKE_TIMEOUT_MS,
 };