@ycodium-ai/agent-grok 0.2.3478 → 0.2.3502

package/dist/index.js

@@ -27722,19 +27722,28 @@ function toAcpMcpServers(entries) {
 }
 
 // ../../packages/ycodium-acp-executor/src/probe.ts
-function withProbeTimeout(promise2, timeoutMs, what) {
+function withProbeTimeout(promise2, timeoutMs, what, signal) {
+  signal?.throwIfAborted();
   return new Promise((resolve2, reject) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal?.reason ?? new Error("aborted"));
+    };
     const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
       reject(new Error(`${what} timed out after ${timeoutMs}ms`));
     }, timeoutMs);
     timer.unref?.();
+    signal?.addEventListener("abort", onAbort, { once: true });
     promise2.then(
       (value) => {
         clearTimeout(timer);
+        signal?.removeEventListener("abort", onAbort);
         resolve2(value);
       },
       (error62) => {
         clearTimeout(timer);
+        signal?.removeEventListener("abort", onAbort);
         reject(error62 instanceof Error ? error62 : new Error(String(error62)));
       }
     );
@@ -27750,14 +27759,16 @@ async function openAcpProbeHandshake(input2) {
     const initializeResult = await withProbeTimeout(
       connection.request("initialize", acpInitializePayload(input2.clientInfo)),
       input2.requestTimeoutMs,
-      "ACP probe request 'initialize'"
+      "ACP probe request 'initialize'",
+      input2.signal
     );
     return {
       initializeResult,
       request: (method, params) => withProbeTimeout(
         connection.request(method, params),
         input2.requestTimeoutMs,
-        `ACP probe request '${method}'`
+        `ACP probe request '${method}'`,
+        input2.signal
       ),
       close: () => connection.close()
     };
@@ -27781,42 +27792,50 @@ async function collectCappedText(stream, maxBytes) {
   return { text: text3 + decoder.decode(), overflowed: total > maxBytes };
 }
 async function collectProbeProcess(child, input2) {
+  const stdinClosed = Promise.resolve().then(() => child.closeStdin());
+  const stdout = collectCappedText(child.stdout, input2.maxOutputBytes);
+  const stderr = collectCappedText(child.stderr, input2.maxOutputBytes);
+  const tasks = [stdinClosed, stdout, stderr, child.exited];
+  let result;
+  let bodyFailed = false;
+  let bodyError;
   try {
-    await child.closeStdin().catch(() => void 0);
-    const [stdout, stderr, exitCode] = await withProbeTimeout(
-      Promise.all([
-        collectCappedText(child.stdout, input2.maxOutputBytes),
-        collectCappedText(child.stderr, input2.maxOutputBytes),
-        child.exited
-      ]),
+    const [, out, err, exitCode] = await withProbeTimeout(
+      Promise.all(tasks),
       input2.timeoutMs,
-      input2.what
+      input2.what,
+      input2.signal
     );
-    return { stdout: stdout.overflowed ? void 0 : stdout.text, stderr: stderr.text, exitCode };
-  } finally {
-    await child.kill("SIGTERM").catch(() => void 0);
-  }
-}
-var MAX_VERSION_OUTPUT_BYTES = 64 * 1024;
-async function probeCliVersion(input2) {
-  let child;
-  try {
-    child = await input2.spawn();
-  } catch {
-    return null;
+    result = { stdout: out.overflowed ? void 0 : out.text, stderr: err.text, exitCode };
+  } catch (error62) {
+    bodyFailed = true;
+    bodyError = error62;
   }
+  const term = Promise.resolve().then(() => child.kill("SIGTERM"));
+  void term.catch(() => void 0);
+  const cleanup = (async () => {
+    try {
+      await withProbeTimeout(child.exited, 250, `${input2.what} termination grace`);
+    } catch {
+      await child.kill("SIGKILL");
+    }
+    const settled = await Promise.allSettled([term, ...tasks]);
+    const termination = settled[0];
+    if (termination?.status === "rejected") throw termination.reason;
+  })();
   try {
-    const run = await collectProbeProcess(child, {
-      timeoutMs: input2.timeoutMs,
-      maxOutputBytes: MAX_VERSION_OUTPUT_BYTES,
-      what: "--version"
-    });
-    if (run.exitCode !== 0) return null;
-    return parseCliVersion(run.stdout ?? "") ?? parseCliVersion(run.stderr);
-  } catch {
-    return null;
+    await withProbeTimeout(cleanup, input2.cleanupTimeoutMs ?? 5e3, `${input2.what} cleanup`);
+  } catch (cleanupError) {
+    throw new AggregateError(
+      bodyFailed ? [bodyError, cleanupError] : [cleanupError],
+      `${input2.what} cleanup failed`,
+      { cause: cleanupError }
+    );
   }
+  if (bodyFailed) throw bodyError;
+  return result;
 }
+var MAX_VERSION_OUTPUT_BYTES = 64 * 1024;
 
 // src/config.ts
 var GROK_DEFAULT_LAUNCH_ARGS = "agent stdio";
@@ -29098,6 +29117,10 @@ function grokOpenCommands(session) {
 }
 
 // src/modelCacheRefresh.ts
+import {
+  runProcessOperation as runProcessOperation2,
+  OperationCleanupError as OperationCleanupError2
+} from "@ycodium-ai/plugin-api/process-operation";
 import * as NodeFS4 from "node:fs";
 import * as NodePath7 from "node:path";
 import {
@@ -29107,6 +29130,10 @@ import {
 } from "@ycodium-ai/plugin-api/executor";
 
 // src/probeModels.ts
+import {
+  runProcessOperation,
+  OperationCleanupError
+} from "@ycodium-ai/plugin-api/process-operation";
 import {
   describeExecutorSpawnFailure,
   ExecutorSpawnAbortedError,
@@ -29166,16 +29193,22 @@ async function probeGrokModels(input2) {
 }
 async function probeGrokVersion(input2) {
   const { recipe, host, env, signal } = input2;
-  return probeCliVersion({
-    spawn: () => host.process.spawn({
+  try {
+    const run = await runProcessOperation(host, {
       program: recipe.binaryPath,
       args: ["--version"],
       owner: { bindingId: host.bindingId },
       ...Object.keys(env).length > 0 ? { env } : {},
-      ...signal === void 0 ? {} : { signal }
-    }),
-    timeoutMs: PROBE_REQUEST_TIMEOUT_MS
-  });
+      signal,
+      timeoutMs: PROBE_REQUEST_TIMEOUT_MS,
+      maxOutputBytes: 64 * 1024
+    });
+    if (run.exitCode !== 0) return null;
+    return parseCliVersion(run.stdout) ?? parseCliVersion(run.stderr);
+  } catch (error62) {
+    if (error62 instanceof OperationCleanupError || signal?.aborted) throw error62;
+    return null;
+  }
 }
 
 // src/modelCacheRefresh.ts
@@ -29198,58 +29231,33 @@ function grokModelCacheNeedsRefresh(input2) {
   if (input2.nowMs - input2.cacheMtimeMs > GROK_MODEL_CACHE_MAX_AGE_MS) return true;
   return input2.lastSeenCliVersion !== null && input2.cliVersion !== null && input2.cliVersion !== input2.lastSeenCliVersion;
 }
-async function drain(stream) {
-  for await (const chunk of stream) {
-    void chunk;
-  }
-}
 async function runGrokModelsCommand(input2) {
   const { recipe, host, env } = input2;
   throwIfExecutorSpawnAborted(input2.signal);
-  let handle;
   try {
-    handle = await host.process.spawn({
+    const run = await runProcessOperation2(host, {
       program: recipe.binaryPath,
       args: ["models"],
       cwd: process.cwd(),
       owner: { bindingId: host.bindingId },
       ...Object.keys(env).length > 0 ? { env } : {},
-      ...input2.signal === void 0 ? {} : { signal: input2.signal }
-    });
-  } catch (error62) {
-    if (error62 instanceof ExecutorSpawnAbortedError2) throw error62;
-    host.log.warn("grok models could not be started; keeping the previous model list", {
-      detail: error62 instanceof ExecutorSpawnRefusedError2 ? "process limit" : String(error62)
+      signal: input2.signal,
+      timeoutMs: GROK_MODELS_COMMAND_TIMEOUT_MS
     });
-    return false;
-  }
-  const finished = Promise.all([drain(handle.stdout), drain(handle.stderr), handle.exited]).then(
-    ([, , code]) => code
-  );
-  let timer;
-  const timeout = new Promise((resolve2) => {
-    timer = setTimeout(() => resolve2("timeout"), GROK_MODELS_COMMAND_TIMEOUT_MS);
-    timer.unref?.();
-  });
-  try {
-    const outcome = await Promise.race([finished, timeout]);
-    if (outcome === "timeout") {
-      finished.catch(() => void 0);
-      host.log.warn("grok models timed out; keeping the previous model list", {
-        timeoutMs: GROK_MODELS_COMMAND_TIMEOUT_MS
-      });
-      return false;
-    }
-    if (outcome !== 0) {
+    if (run.exitCode !== 0) {
       host.log.warn("grok models exited non-zero; keeping the previous model list", {
-        exitCode: outcome
+        exitCode: run.exitCode
       });
       return false;
     }
     return true;
-  } finally {
-    if (timer !== void 0) clearTimeout(timer);
-    await handle.kill("SIGTERM").catch(() => void 0);
+  } catch (error62) {
+    if (error62 instanceof ExecutorSpawnAbortedError2 || error62 instanceof OperationCleanupError2 || input2.signal?.aborted)
+      throw error62;
+    host.log.warn("grok models failed; keeping the previous model list", {
+      detail: error62 instanceof ExecutorSpawnRefusedError2 ? "process limit" : String(error62)
+    });
+    return false;
   }
 }
 var modelsCommandSlots = /* @__PURE__ */ new Map();
@@ -29295,7 +29303,7 @@ function createGrokModelCatalog(input2) {
   };
   const refreshModelCatalog = async (request) => {
     try {
-      const cliVersion = request.cliVersion !== void 0 ? request.cliVersion : await readCliVersion();
+      const cliVersion = request.cliVersion !== void 0 ? request.cliVersion : await readCliVersion(request.signal);
       if (!request.force && skipUnforced) {
         skipUnforced = false;
         if (cliVersion !== null) lastSeenCliVersion = cliVersion;
@@ -29327,7 +29335,8 @@ function createGrokModelCatalog(input2) {
         throw new Error("grok models failed");
       }
     } catch (error62) {
-      if (error62 instanceof ExecutorSpawnAbortedError2) throw error62;
+      if (error62 instanceof ExecutorSpawnAbortedError2 || error62 instanceof OperationCleanupError2 || request.signal?.aborted)
+        throw error62;
       if (request.surfaceErrors === true) throw error62;
       input2.host.log.warn("grok model cache refresh failed; keeping the previous model list", {
         detail: error62 instanceof Error ? error62.message : String(error62)
@@ -29506,8 +29515,12 @@ var createGrokInstance = (config2, host) => {
   const signIn = makeGrokSignIn({ host, recipe, probe, isDisposed: () => disposed });
   const instance = {
     probe,
-    readCliVersion: () => modelCatalog.readCliVersion(),
-    refreshModelCatalog: ({ force }) => modelCatalog.refreshModelCatalog({ force, armProbeSkip: force }),
+    readCliVersion: (signal) => modelCatalog.readCliVersion(signal),
+    refreshModelCatalog: ({ force, signal }) => modelCatalog.refreshModelCatalog({
+      force,
+      armProbeSkip: force,
+      ...signal === void 0 ? {} : { signal }
+    }),
     // 项目里的技能：探测在 home 下跑 inspect 只看得到整机的；这里在项目目录里再跑一次。
     workspaceInventory: ({ cwd }) => {
       if (recipe.binaryPath.length === 0) {
@@ -29806,7 +29819,7 @@ var executors = [
 ];
 var index_default = definePlugin({
   id: "agent-grok",
-  apiVersion: 39,
+  apiVersion: 41,
   executors,
   activate(ctx) {
     ctx.log.info("grok executor ready");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ycodium-ai/agent-grok",
-  "version": "0.2.3478",
+  "version": "0.2.3502",
   "description": "Grok executor: grok CLI over Agent Client Protocol stdio.",
   "keywords": [
     "ycodium",
@@ -21,8 +21,8 @@
     "@types/node": "24.12.4",
     "esbuild": "0.28.1",
     "vite-plus": "0.2.2",
-    "@ycodium-ai/plugin-api": "0.2.3478",
-    "ycodium-acp-executor": "0.2.3478",
+    "@ycodium-ai/plugin-api": "0.2.3502",
+    "ycodium-acp-executor": "0.2.3502",
     "ycodium-executor-testing": "0.0.0"
   },
   "ycodium": {