@ycodium-ai/agent-antigravity 0.2.3202 → 0.2.3208

package/dist/index.js

@@ -28812,6 +28812,9 @@ function createAcpSessionRegistry(threads, stopBooked) {
     if (!booked) return Promise.resolve();
     booked.closing ??= Promise.resolve().then(() => stopBooked(booked)).then(() => {
       if (threads.get(threadId) === booked) threads.delete(threadId);
+    }).catch((cause) => {
+      if (threads.get(threadId) === booked) delete booked.closing;
+      throw cause;
     });
     return booked.closing;
   };
@@ -28821,6 +28824,61 @@ function createAcpSessionRegistry(threads, stopBooked) {
   return { requireThread, stopSession, stopAll };
 }
 
+// ../../packages/ycodium-acp-executor/src/session-cleanup.ts
+var reportedForwardingFailures = /* @__PURE__ */ new WeakSet();
+async function cleanupAcpSession(input2) {
+  const failures = [];
+  const forwarding = input2.forwarding.catch((cause) => {
+    if (reportedForwardingFailures.has(input2.forwarding)) return;
+    reportedForwardingFailures.add(input2.forwarding);
+    failures.push(new Error(`forwarding failed: ${String(cause)}`, { cause }));
+  });
+  for (const [step, cleanup] of [
+    ["executor.dispose", () => input2.executor.dispose()],
+    ["stopProcess", input2.stopProcess],
+    ["forwarding", () => forwarding]
+  ]) {
+    try {
+      await cleanup();
+    } catch (cause) {
+      failures.push(new Error(`${step} failed: ${String(cause)}`, { cause }));
+    }
+  }
+  if (failures.length > 0) {
+    throw new AggregateError(failures, failures.map((error62) => error62.message).join("; "));
+  }
+}
+async function cleanupAcpStartup(input2) {
+  try {
+    await cleanupAcpSession(input2);
+    return true;
+  } catch (cleanupError) {
+    input2.log.warn("ACP session startup cleanup failed", {
+      threadId: input2.threadId,
+      error: String(cleanupError)
+    });
+    return false;
+  }
+}
+function createRetryableClose(run) {
+  let task;
+  return () => {
+    if (task) return task;
+    const done = Promise.withResolvers();
+    const current = done.promise;
+    task = current;
+    void current.catch(() => {
+      if (task === current) task = void 0;
+    });
+    try {
+      run().then(done.resolve, done.reject);
+    } catch (cause) {
+      done.reject(cause);
+    }
+    return current;
+  };
+}
+
 // ../../packages/ycodium-acp-executor/src/start-abort.ts
 function throwIfStartAborted(signal) {
   if (signal?.aborted) throw new Error("aborted");
@@ -29187,37 +29245,63 @@ async function* watchAgentStderr(source, onLoginPrompt, onBrowserHelperLine) {
 async function waitForExit(handle, timeoutMs, clock) {
   let cancel = () => {
   };
-  const exited = await Promise.race([
-    handle.exited.then(
-      () => true,
-      () => true
-    ),
-    new Promise((resolve6) => {
-      cancel = clock.delay(timeoutMs, () => resolve6(false));
-    })
-  ]);
-  cancel();
-  return exited;
+  try {
+    return await Promise.race([
+      handle.exited.then(() => true),
+      new Promise((resolve6) => {
+        cancel = clock.delay(timeoutMs, () => resolve6(false));
+      })
+    ]);
+  } finally {
+    cancel();
+  }
 }
 function stopAgentProcess(handle, exitWaitMs, log, clock = realAgentClock) {
-  let stopping = stoppingByHandle.get(handle);
-  if (stopping === void 0) {
-    stopping = terminate(handle, exitWaitMs, log, clock);
-    stoppingByHandle.set(handle, stopping);
+  let stopper = stoppersByHandle.get(handle);
+  if (stopper === void 0) {
+    const created = {
+      args: { exitWaitMs, log, clock },
+      stop: createRetryableClose(
+        () => terminate(handle, created.args.exitWaitMs, created.args.log, created.args.clock)
+      )
+    };
+    stoppersByHandle.set(handle, created);
+    stopper = created;
   }
-  return stopping;
+  stopper.args = { exitWaitMs, log, clock };
+  return stopper.stop();
 }
-var stoppingByHandle = /* @__PURE__ */ new WeakMap();
+var stoppersByHandle = /* @__PURE__ */ new WeakMap();
 async function terminate(handle, exitWaitMs, log, clock) {
-  await handle.kill("SIGTERM").catch(() => void 0);
-  if (await waitForExit(handle, exitWaitMs, clock)) return;
-  log.warn("the agent process ignored SIGTERM; killing it", { pid: handle.pid, exitWaitMs });
-  await handle.kill("SIGKILL").catch(() => void 0);
-  if (await waitForExit(handle, exitWaitMs, clock)) return;
-  log.error("the agent process is still running after SIGKILL; leaving it behind", {
-    pid: handle.pid,
-    exitWaitMs
-  });
+  const failures = [];
+  for (const signal of ["SIGTERM", "SIGKILL"]) {
+    try {
+      await handle.kill(signal);
+    } catch (cause) {
+      failures.push(new Error(`${signal} failed: ${String(cause)}`, { cause }));
+    }
+    try {
+      if (await waitForExit(handle, exitWaitMs, clock)) {
+        if (failures.length > 0) {
+          log.warn("the agent process exited after a signal failed", {
+            pid: handle.pid,
+            error: failures.map((error62) => error62.message).join("; ")
+          });
+        }
+        return;
+      }
+    } catch (cause) {
+      failures.push(new Error(`waitForExit after ${signal} failed: ${String(cause)}`, { cause }));
+    }
+    if (signal === "SIGTERM") {
+      log.warn("the agent process ignored SIGTERM; killing it", { pid: handle.pid, exitWaitMs });
+    } else {
+      const message = "the agent process is still running after SIGKILL; leaving it behind";
+      log.error(message, { pid: handle.pid, exitWaitMs });
+      failures.push(new Error(message));
+    }
+  }
+  throw new AggregateError(failures, failures.map((error62) => error62.message).join("; "));
 }
 async function openAgentProcess(input2) {
   await prepareAntigravityProfile(input2.profile);
@@ -29282,7 +29366,13 @@ async function openAgentProcess(input2) {
   const close = () => {
     closing ??= (async () => {
       await connection.close().catch(() => void 0);
-      await stopAgentProcess(handle, input2.exitWaitMs, input2.host.log, clock);
+      await stopAgentProcess(handle, input2.exitWaitMs, input2.host.log, clock).catch(
+        (error62) => {
+          input2.host.log.warn("could not confirm the agent process exited", {
+            error: String(error62)
+          });
+        }
+      );
       await removeRuntimeTempDir(directory);
     })();
     return closing;
@@ -30466,10 +30556,14 @@ function createAntigravitySession({
         });
         return session;
       } catch (error62) {
-        await executor.dispose().catch(() => void 0);
-        await stopAgentProcess(handle, exitWaitMs, host.log, clock);
-        await forwarding.catch(() => void 0);
-        await removeRuntimeTempDir(runtimeTemp);
+        const cleaned = await cleanupAcpStartup({
+          executor,
+          stopProcess: () => stopAgentProcess(handle, exitWaitMs, host.log, clock),
+          forwarding,
+          log: host.log,
+          threadId: input2.threadId
+        });
+        if (cleaned) await removeRuntimeTempDir(runtimeTemp);
         if (live.signInRequired || isSignInRequiredError(error62)) {
           await noteSession(() => login.noteSessionSignedOut());
           throw new AntigravitySignInRequiredError();
@@ -32025,7 +32119,13 @@ function createAntigravityTextGeneration(deps) {
       stopped = true;
       await executor?.dispose().catch(() => void 0);
       if (handle !== void 0)
-        await stopAgentProcess(handle, deps.exitWaitMs, deps.host.log, clock);
+        await stopAgentProcess(handle, deps.exitWaitMs, deps.host.log, clock).catch(
+          (error62) => {
+            deps.host.log.warn("could not confirm the text generation process exited", {
+              error: String(error62)
+            });
+          }
+        );
       await pump?.catch(() => void 0);
       if (runtimeTemp !== void 0) await removeRuntimeTempDir(runtimeTemp);
       if (workspace !== void 0) {
@@ -32332,7 +32432,6 @@ async function createAntigravityInstance(config2, host, deps) {
   const events = new EventBus();
   const threads = /* @__PURE__ */ new Map();
   const mutable = { disposed: false };
-  let disposeTask;
   const unregister = deps.runtime.registerInstance({
     instanceId: host.instanceId,
     host,
@@ -32347,9 +32446,11 @@ async function createAntigravityInstance(config2, host, deps) {
   const resolveExecutable = () => deps.runtime.resolve(resolveInput);
   const stopBooked = async (booked) => {
     for (const stopped of booked.background.finish()) events.push(stopped);
-    await booked.executor.dispose().catch(() => void 0);
-    await stopAgentProcess(booked.handle, exitWaitMs, host.log, clock);
-    await booked.forwarding.catch(() => void 0);
+    await cleanupAcpSession({
+      executor: booked.executor,
+      stopProcess: () => stopAgentProcess(booked.handle, exitWaitMs, host.log, clock),
+      forwarding: booked.forwarding
+    });
     if (!await removeRuntimeTempDir(booked.runtimeTemp)) {
       host.log.warn("could not remove a runtime temp directory; it is swept on the next start", {
         directory: booked.runtimeTemp
@@ -32404,6 +32505,21 @@ async function createAntigravityInstance(config2, host, deps) {
     runtimeSeen = state;
     void login.syncProgram();
   });
+  let unregistered = false;
+  const disposeOnce = createRetryableClose(async () => {
+    if (!unregistered) {
+      unregistered = true;
+      unregisterLogin();
+      unsubscribeRuntime();
+      try {
+        await login.dispose();
+      } finally {
+        unregister();
+      }
+    }
+    await Promise.all([stopAll(), helpers.stopRunning()]);
+    events.close();
+  });
   const signedInFile = signedInMarkerFile(dirs.profile);
   const noteSession = (note) => note().catch((error62) => {
     host.log.warn("could not update the signed-in marker", {
@@ -32576,17 +32692,8 @@ async function createAntigravityInstance(config2, host, deps) {
     textGeneration: helpers.textGeneration,
     continuationKey: dirs.continuationKey,
     dispose: () => {
-      if (disposeTask) return disposeTask;
       mutable.disposed = true;
-      disposeTask = (async () => {
-        unregisterLogin();
-        unsubscribeRuntime();
-        await login.dispose();
-        unregister();
-        await Promise.all([stopAll(), helpers.stopRunning()]);
-        events.close();
-      })();
-      return disposeTask;
+      return disposeOnce();
     }
   };
   return instance;
@@ -33191,7 +33298,11 @@ async function validateInstalledRuntime(input2) {
   } finally {
     await closeHandshake?.().catch(() => void 0);
     if (handle !== void 0) {
-      await stopAgentProcess(handle, EXIT_WAIT_MS, input2.host.log);
+      await stopAgentProcess(handle, EXIT_WAIT_MS, input2.host.log).catch((error62) => {
+        input2.host.log.warn("could not confirm the validation process exited", {
+          error: String(error62)
+        });
+      });
     }
     await removeRuntimeTempDir(runtimeTemp);
     await removeRuntimeTempDir(profile);
@@ -33661,7 +33772,7 @@ var executors = [
 ];
 var index_default = definePlugin({
   id: "agent-antigravity",
-  apiVersion: 18,
+  apiVersion: 19,
   executors,
   activate(ctx) {
     const runtime = createRuntimeManager({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ycodium-ai/agent-antigravity",
-  "version": "0.2.3202",
+  "version": "0.2.3208",
   "description": "Google Antigravity executor: runs the Antigravity agent over Agent Client Protocol stdio.",
   "keywords": [
     "ycodium",
@@ -31,9 +31,9 @@
     "typescript": "~6.0.3",
     "vite-plus": "0.2.2",
     "yauzl": "^3.4.0",
-    "@ycodium-ai/plugin-api": "0.2.3202",
+    "@ycodium-ai/plugin-api": "0.2.3208",
     "ycodium-executor-testing": "0.0.0",
-    "ycodium-acp-executor": "0.2.3202"
+    "ycodium-acp-executor": "0.2.3208"
   },
   "ycodium": {
     "plugin": "./dist/index.js",