openmausbot 0.1.55 → 0.1.57

package/dist-server/server/drivers/antigravity-acp.js

@@ -127,6 +127,10 @@ export class AntigravityAcpClient {
     diagnosticBuffer = "";
     closed = false;
     onAuthorizationUrl;
+    /** Settles once the runtime process is gone. On Windows a running
+     * executable pins its file and its directory, so an installer must not
+     * rename or delete either until this settles. */
+    exited;
     constructor(runtime, profile, cwd, onAuthorizationUrl) {
         this.onAuthorizationUrl = onAuthorizationUrl;
         this.child = spawnCli(runtime.executablePath, process.platform === "linux" ? ["--uid="] : [], { cwd, env: profile.environment, stdio: ["pipe", "pipe", "pipe"] });
@@ -138,9 +142,14 @@ export class AntigravityAcpClient {
         this.child.stderr.setEncoding("utf8");
         this.child.stderr.on("data", (chunk) => this.consumeDiagnostics(chunk));
         this.child.once("error", (error) => this.failAll(error));
-        this.child.once("close", (code) => {
-            if (!this.closed)
-                this.failAll(new Error(`Antigravity ACP exited ${code ?? "unexpectedly"}.`));
+        this.exited = new Promise((resolve) => {
+            this.child.once("close", (code) => {
+                if (!this.closed)
+                    this.failAll(new Error(`Antigravity ACP exited ${code ?? "unexpectedly"}.`));
+                resolve();
+            });
+            // Failed spawns also emit `close`. An `error` alone can instead mean
+            // a failed kill, and is not evidence that the runtime stopped.
         });
     }
     consume(chunk) {
@@ -239,6 +248,22 @@ export class AntigravityAcpClient {
         this.failAll(new Error("Antigravity ACP was closed."));
         killCliTree(this.child);
     }
+    /** Close, then wait (bounded) for the process to be gone. `killCliTree`
+     * on Windows asks taskkill and returns at once; the exit lands later. */
+    async closeAndWait(timeoutMs = 5_000) {
+        this.close();
+        let timer;
+        const timedOut = new Promise((resolve) => {
+            timer = setTimeout(() => resolve(false), timeoutMs);
+            timer.unref?.();
+        });
+        try {
+            return await Promise.race([this.exited.then(() => true), timedOut]);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
 }
 export function parseAntigravityAuthorizationUrl(authorizationUrl) {
     if (authorizationUrl.length > 16_384 || /\s/u.test(authorizationUrl)) {
@@ -407,26 +432,49 @@ export function isValidAntigravityInitializeResult(initialized, expectedVersion)
  */
 export async function validateAntigravityRuntime(runtime, expectedVersion) {
     const profileDirectory = await mkdtemp(join(tmpdir(), "openmaus-antigravity-verify-"));
+    let client;
+    let failed = false;
+    let failure;
     try {
         const profile = await prepareAntigravityProfile({
             instanceId: `verify-${randomUUID()}`,
             runtime,
             profileDirectory,
         });
-        const client = new AntigravityAcpClient(runtime, profile, profileDirectory);
-        try {
-            const initialized = await client.initialize();
-            if (!isValidAntigravityInitializeResult(initialized, expectedVersion)) {
-                throw new Error("The download did not identify as the expected Google Antigravity ACP release.");
-            }
+        client = new AntigravityAcpClient(runtime, profile, profileDirectory);
+        const initialized = await client.initialize();
+        if (!isValidAntigravityInitializeResult(initialized, expectedVersion)) {
+            throw new Error("The download did not identify as the expected Google Antigravity ACP release.");
         }
-        finally {
-            client.close();
+    }
+    catch (error) {
+        failed = true;
+        failure = error;
+    }
+    // The caller is about to rename the directory this executable runs from.
+    // Neither it nor the profile is safe to touch before confirmed close.
+    let stopped = !client;
+    try {
+        if (client) {
+            stopped = await client.closeAndWait();
+            if (!stopped)
+                throw new Error("Antigravity did not shut down after runtime verification.");
         }
     }
-    finally {
-        await rm(profileDirectory, { recursive: true, force: true });
+    catch (error) {
+        if (!failed) {
+            failed = true;
+            failure = error;
+        }
+    }
+    if (stopped) {
+        await rm(profileDirectory, { recursive: true, force: true, maxRetries: 4, retryDelay: 250 })
+            .catch((error) => {
+            console.warn(`antigravity: could not remove verification profile ${profileDirectory}: ${error instanceof Error ? error.message : String(error)}`);
+        });
     }
+    if (failed)
+        throw failure;
 }
 /** One in-flight personal Google login per provider instance. */
 export class AntigravityAuthController {

package/dist-server/server/drivers/antigravity-runtime.js

@@ -11,6 +11,33 @@ import { augmentedPath } from "../env-path.js";
 import { resolveAntigravityReleaseAsset, } from "./antigravity-release.js";
 const FREE_SPACE_MARGIN = 256 * 1024 * 1024;
 const DOWNLOAD_TIMEOUT_MS = 45 * 60_000;
+const STAGING_PREFIX = ".install-";
+/** Windows refuses to rename or delete a file something still holds open,
+ * with EPERM/EBUSY/EACCES rather than a clear "in use": the runtime the
+ * validator just stopped (taskkill is asynchronous) or an antivirus scan of
+ * a brand-new executable. Retry briefly; persistent refusals still fail. */
+export function transientWindowsFileError(error) {
+    const code = typeof error === "object" && error !== null ? Reflect.get(error, "code") : undefined;
+    return code === "EPERM" || code === "EBUSY" || code === "EACCES" || code === "ENOTEMPTY";
+}
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/** Retry a filesystem step on the transient Windows refusals above, with
+ * growing delays (default: 8 tries, 0.25 s → 2 s, about 10 s in total).
+ * Anything else, and the final failure, surface unchanged. */
+export async function retryOnWindowsFileLock(step, options = {}) {
+    const attempts = options.attempts ?? 8;
+    const sleep = options.sleep ?? wait;
+    for (let attempt = 1;; attempt += 1) {
+        try {
+            return await step();
+        }
+        catch (error) {
+            if (attempt >= attempts || !transientWindowsFileError(error))
+                throw error;
+            await sleep(Math.min(2_000, (options.delayMs ?? 250) * 2 ** (attempt - 1)));
+        }
+    }
+}
 const INSTALL_RECORD = ".install-complete.json";
 export class AntigravitySetupError extends Error {
     status = 409;
@@ -293,7 +320,10 @@ async function installOnce(options) {
         // statfs is unavailable on a few filesystems. The bounded download and
         // extraction checks still fail safely if the disk fills.
     }
-    const staging = await mkdtemp(join(versions, `.install-${randomUUID()}-`));
+    // Another app/server process may be installing into this versions folder.
+    // The in-memory coalescing map cannot protect its staging directory.
+    const staging = await mkdtemp(join(versions, `${STAGING_PREFIX}${randomUUID()}-`));
+    let failed = false;
     try {
         const archivePath = join(staging, "download.zip");
         const runtimeDirectory = join(staging, "runtime");
@@ -364,7 +394,7 @@ async function installOnce(options) {
         };
         await writeFile(join(runtimeDirectory, INSTALL_RECORD), `${JSON.stringify(record)}\n`, { flag: "wx", mode: 0o600 });
         try {
-            await rename(runtimeDirectory, destination);
+            await retryOnWindowsFileLock(() => rename(runtimeDirectory, destination));
         }
         catch (error) {
             const winner = await completedRelease(destination, asset);
@@ -376,8 +406,22 @@ async function installOnce(options) {
             throw new Error("The installed Antigravity runtime is incomplete.");
         return installed;
     }
+    catch (error) {
+        failed = true;
+        throw error;
+    }
     finally {
-        await rm(staging, { recursive: true, force: true });
+        // Cleanup must never replace the real error with its own: a user who
+        // saw "EPERM: unlink agy_acp_server.exe" was looking at this line, not
+        // at why the install failed. Only clean up this attempt's directory;
+        // if it stays locked, log and leave it without touching other attempts.
+        try {
+            await retryOnWindowsFileLock(() => rm(staging, { recursive: true, force: true }));
+        }
+        catch (cleanupError) {
+            const detail = cleanupError instanceof Error ? cleanupError.message : String(cleanupError);
+            console.warn(`antigravity: could not remove the install folder ${staging} (${detail})${failed ? "" : "; the install itself succeeded"}`);
+        }
     }
 }
 /** Coalesce concurrent clicks so only one large Google artifact is fetched. */

package/dist-server/server/drivers/claude.js

@@ -774,7 +774,10 @@ export const ClaudeDriver = {
                 if (live.idleTimer)
                     clearTimeout(live.idleTimer);
                 live.turn = { turnId, settled: false, sawStreamDelta: false };
-                active.set(threadId, { stop: () => killCliTree(live.child), turnId, broker: live.broker });
+                active.set(threadId, { stop: () => {
+                        closeSession(threadId, "interrupted");
+                        killCliTree(live.child);
+                    }, turnId, broker: live.broker });
                 emit({ ...base(threadId, turnId), type: "turn.started" });
                 const written = await writeUser(live, threadId, promptMsg);
                 if (!written) {
@@ -1175,6 +1178,9 @@ export const ClaudeDriver = {
                     sessions.delete(threadId);
             });
             const stop = () => {
+                // taskkill is asynchronous on Windows. Retire steering and approvals
+                // now, before a still-connected child can submit more work.
+                closeSession(threadId, "interrupted");
                 retry.cancelled = true;
                 retryAbort.abort();
                 killCliTree(child);

package/dist-server/server/exit.js

@@ -0,0 +1,9 @@
+// End the process with a code once stdout and stderr have flushed. On Linux a
+// pipe (CI's `| grep`, a journal) takes writes asynchronously, so
+// `process.exit` right after `console.error` can drop the very line that
+// says what went wrong. A write callback fires only once its data is out.
+export function exitAfterFlush(code) {
+    process.exitCode = code;
+    const flushed = (stream) => new Promise((done) => stream.write("", () => done()));
+    void Promise.all([flushed(process.stdout), flushed(process.stderr)]).then(() => process.exit(code));
+}