openmausbot 0.1.55

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

@@ -0,0 +1,507 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, mkdtemp, readFile, rm, stat } from "node:fs/promises";
+import { request as httpRequest } from "node:http";
+import { tmpdir } from "node:os";
+import { delimiter, join, resolve } from "node:path";
+import { DATA_DIR, stripWorkspaceCredentialEnv } from "../config.js";
+import { writeFileAtomic } from "../atomic.js";
+import { killCliTree, spawnCli } from "../procs.js";
+// Printed on stderr by Google's server, not stdout.
+export const ANTIGRAVITY_AUTH_PREFIX = "Open the following link to authenticate the ACP server: ";
+const AUTH_TIMEOUT_MS = 5 * 60_000;
+// Google's packaged server can take tens of seconds to cold-start, especially
+// on Windows. Match T3 Code's bounded setup allowance, not a fast CLI probe.
+const STARTUP_TIMEOUT_MS = 90_000;
+const MAX_PROTOCOL_LINE_BYTES = 16 * 1024 * 1024;
+// Past the 16 KiB ceiling parseAntigravityAuthorizationUrl accepts, so a
+// partial stderr line is never dropped while it could still become a link.
+const MAX_DIAGNOSTIC_LINE_CHARS = 64 * 1024;
+const REMOVED_ENVIRONMENT_KEYS = new Set([
+    "GEMINI_API_KEY",
+    "GOOGLE_API_KEY",
+    "GOOGLE_APPLICATION_CREDENTIALS",
+    "GOOGLE_CLOUD_PROJECT",
+    "GOOGLE_CLOUD_LOCATION",
+    "GOOGLE_CLOUD_QUOTA_PROJECT",
+    "GOOGLE_GENAI_USE_VERTEXAI",
+    "GCLOUD_PROJECT",
+    "CLOUDSDK_CORE_PROJECT",
+    "AGY_ACP_CCPA_PROJECT",
+    "AGY_ACP_ENABLE_OAUTH",
+    "GEMINI_HOME",
+    "AGY_ACP_FORCE_FILE_STORAGE",
+    "ANTIGRAVITY_HARNESS_PATH",
+    "BROWSER",
+    "PYTHONUNBUFFERED",
+    "ELECTRON_RUN_AS_NODE",
+]);
+const BROWSER_MARKER = "__OPENMAUS_ANTIGRAVITY_AUTH_URL__";
+const browserHelperSource = `process.stderr.on("error",()=>process.exit(0)).write(` +
+    `"${BROWSER_MARKER}"+JSON.stringify(process.argv[1])+"\\n",` +
+    `()=>process.exit(0))`;
+function quoteBrowserArgument(value) {
+    return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+/** Complete lines in a stream buffer, plus the unterminated tail to keep. */
+function takeLines(buffer) {
+    const parts = buffer.split("\n");
+    const rest = parts.pop() ?? "";
+    return { lines: parts.map((line) => line.replace(/\r$/u, "")), rest };
+}
+/** The sign-in link in a server output line, or null for anything else.
+ * Google announces it two ways and both land on stderr: it hands the link to
+ * $BROWSER — our helper re-emits it JSON-encoded behind a private marker — and
+ * it also prints the link in plain text for terminal users. Either is enough;
+ * the marker form is preferred because JSON delimits the URL exactly. */
+export function authorizationUrlFromLine(line) {
+    if (line.startsWith(ANTIGRAVITY_AUTH_PREFIX))
+        return line.slice(ANTIGRAVITY_AUTH_PREFIX.length).trim();
+    if (!line.startsWith(BROWSER_MARKER))
+        return null;
+    try {
+        const url = JSON.parse(line.slice(BROWSER_MARKER.length));
+        return typeof url === "string" ? url : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function antigravityProfileDirectory(instanceId, baseDir = DATA_DIR) {
+    return join(baseDir, "providers", "antigravity", createHash("sha256").update(instanceId).digest("hex"));
+}
+/** Every configured Antigravity instance gets an isolated Google profile.
+ * Foreign Google credentials are deliberately stripped so selecting this
+ * provider can never silently change the account or billing path. */
+export async function prepareAntigravityProfile(input) {
+    const directory = resolve(input.profileDirectory ?? antigravityProfileDirectory(input.instanceId, input.baseDir));
+    const acpDirectory = join(directory, "antigravity-acp");
+    await mkdir(acpDirectory, { recursive: true, mode: 0o700 });
+    if (process.platform !== "win32") {
+        const { chmod } = await import("node:fs/promises");
+        await chmod(directory, 0o700);
+        await chmod(acpDirectory, 0o700);
+    }
+    writeFileAtomic(join(acpDirectory, "settings.json"), `${JSON.stringify({ auth: { type: "oauth-personal" } })}\n`, { mode: 0o600 });
+    const executable = process.platform === "win32" ? process.execPath.replaceAll("\\", "/") : process.execPath;
+    if (/\r|\n|\0|%s/u.test(executable) || executable.includes(delimiter)) {
+        throw new Error("The OpenMausBot runtime path cannot safely suppress Antigravity browser launches.");
+    }
+    const browserCommand = [executable, "-e", browserHelperSource, "--", "%s"]
+        .map(quoteBrowserArgument)
+        .join(" ");
+    const environment = {};
+    for (const [key, value] of Object.entries(input.baseEnv ?? process.env)) {
+        if (!REMOVED_ENVIRONMENT_KEYS.has(key.toUpperCase()))
+            environment[key] = value;
+    }
+    stripWorkspaceCredentialEnv(environment);
+    Object.assign(environment, {
+        GEMINI_HOME: directory,
+        AGY_ACP_FORCE_FILE_STORAGE: "1",
+        ANTIGRAVITY_HARNESS_PATH: input.runtime.harnessPath,
+        BROWSER: browserCommand,
+        PYTHONUNBUFFERED: "1",
+        ELECTRON_RUN_AS_NODE: "1",
+    });
+    return { directory, tokenPath: join(acpDirectory, "acp_token.json"), environment };
+}
+export async function antigravityProfileAuthenticated(profile) {
+    try {
+        const info = await stat(profile.tokenPath);
+        if (!info.isFile() || info.size <= 0 || info.size > 1024 * 1024)
+            return false;
+        await readFile(profile.tokenPath, { encoding: "utf8" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Tiny dependency-free ACP client for setup/model probes. Actual chat turns
+ * continue to use the shared provider-neutral ACP runtime. */
+export class AntigravityAcpClient {
+    child;
+    nextId = 1;
+    pending = new Map();
+    buffer = "";
+    diagnosticBuffer = "";
+    closed = false;
+    onAuthorizationUrl;
+    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"] });
+        this.child.stdout.setEncoding("utf8");
+        this.child.stdout.on("data", (chunk) => this.consume(chunk));
+        // Google announces the sign-in link on stderr, not stdout. Scan for that
+        // one line and drop every other byte: stderr also carries authorization
+        // codes, so nothing else is retained or surfaced.
+        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"}.`));
+        });
+    }
+    consume(chunk) {
+        this.buffer += chunk;
+        if (Buffer.byteLength(this.buffer) > MAX_PROTOCOL_LINE_BYTES) {
+            this.failAll(new Error("Antigravity sent a protocol line that is too large."));
+            this.close();
+            return;
+        }
+        const { lines, rest } = takeLines(this.buffer);
+        this.buffer = rest;
+        for (const line of lines) {
+            if (this.announceAuthorizationUrl(line))
+                continue;
+            let message;
+            try {
+                message = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (typeof message?.id !== "number")
+                continue;
+            const pending = this.pending.get(message.id);
+            if (!pending)
+                continue;
+            this.pending.delete(message.id);
+            if (pending.timer)
+                clearTimeout(pending.timer);
+            if (message.error) {
+                const error = new Error(message.error.message ?? "Antigravity ACP request failed.");
+                Object.assign(error, { code: message.error.code, data: message.error.data });
+                pending.reject(error);
+            }
+            else
+                pending.resolve(message.result);
+        }
+    }
+    /** Report a sign-in link if this line carries one. Returns whether the line
+     * was an announcement, so callers can skip protocol parsing for it. */
+    announceAuthorizationUrl(line) {
+        const raw = authorizationUrlFromLine(line);
+        if (raw === null)
+            return false;
+        try {
+            this.onAuthorizationUrl?.(parseAntigravityAuthorizationUrl(raw).authorizationUrl);
+        }
+        catch (error) {
+            this.failAll(error instanceof Error ? error : new Error(String(error)));
+        }
+        return true;
+    }
+    /** Read stderr only far enough to spot the sign-in link. Lines are matched
+     * and released immediately and the tail is capped, so no authorization code
+     * is ever held. Draining also keeps the pipe from stalling the server. */
+    consumeDiagnostics(chunk) {
+        const { lines, rest } = takeLines(this.diagnosticBuffer + chunk);
+        // A partial line already longer than any legal link cannot become one.
+        this.diagnosticBuffer = rest.length > MAX_DIAGNOSTIC_LINE_CHARS ? "" : rest;
+        for (const line of lines)
+            this.announceAuthorizationUrl(line);
+    }
+    failAll(error) {
+        for (const pending of this.pending.values()) {
+            if (pending.timer)
+                clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+        this.pending.clear();
+    }
+    request(method, params, timeoutMs = 30_000) {
+        if (this.closed)
+            return Promise.reject(new Error("Antigravity ACP is closed."));
+        const id = this.nextId++;
+        return new Promise((resolveRequest, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`${method} timed out.`));
+            }, timeoutMs);
+            timer.unref?.();
+            this.pending.set(id, { resolve: resolveRequest, reject, timer });
+            this.child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}\n`);
+        });
+    }
+    async initialize(timeoutMs = STARTUP_TIMEOUT_MS) {
+        return this.request("initialize", {
+            protocolVersion: 1,
+            clientInfo: { name: "openmausbot", version: "0.0.0" },
+            clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false },
+        }, timeoutMs);
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.failAll(new Error("Antigravity ACP was closed."));
+        killCliTree(this.child);
+    }
+}
+export function parseAntigravityAuthorizationUrl(authorizationUrl) {
+    if (authorizationUrl.length > 16_384 || /\s/u.test(authorizationUrl)) {
+        throw new Error("Antigravity returned an invalid Google sign-in URL.");
+    }
+    const url = new URL(authorizationUrl);
+    const state = url.searchParams.get("state");
+    const redirectUri = url.searchParams.get("redirect_uri");
+    if (url.origin !== "https://accounts.google.com" ||
+        url.pathname !== "/o/oauth2/v2/auth" ||
+        url.username || url.password || url.hash ||
+        url.searchParams.getAll("state").length !== 1 ||
+        url.searchParams.getAll("redirect_uri").length !== 1 ||
+        url.searchParams.getAll("response_type").length !== 1 ||
+        url.searchParams.get("response_type") !== "code" ||
+        !state || state.length > 512 || /\s/u.test(state) ||
+        !redirectUri || !/^http:\/\/127\.0\.0\.1:[1-9][0-9]{0,4}\/$/u.test(redirectUri))
+        throw new Error("Antigravity returned an invalid Google sign-in URL.");
+    const redirect = new URL(redirectUri);
+    if (Number(redirect.port) < 1024 || Number(redirect.port) > 65535) {
+        throw new Error("Antigravity returned an invalid Google sign-in URL.");
+    }
+    return { authorizationUrl, redirectUri, state };
+}
+export function validateAntigravityCallbackUrl(pending, callbackUrl) {
+    if (callbackUrl.length > 16_384)
+        throw new Error("The sign-in response URL is too long.");
+    let callback;
+    try {
+        callback = new URL(callbackUrl);
+    }
+    catch {
+        throw new Error("Paste the complete redirect URL from Google.");
+    }
+    const expected = new URL(pending.redirectUri);
+    const states = callback.searchParams.getAll("state");
+    const codes = callback.searchParams.getAll("code");
+    const errors = callback.searchParams.getAll("error");
+    const issuers = callback.searchParams.getAll("iss");
+    if (callback.protocol !== "http:" || callback.hostname !== "127.0.0.1" ||
+        callback.origin !== expected.origin || callback.pathname !== expected.pathname ||
+        callback.username || callback.password || callback.hash ||
+        states.length !== 1 || states[0] !== pending.state ||
+        !((codes.length === 1 && codes[0] && errors.length === 0) ||
+            (errors.length === 1 && errors[0] && codes.length === 0)) ||
+        issuers.length > 1 || (issuers.length === 1 && issuers[0] !== "https://accounts.google.com"))
+        throw new Error("This redirect URL does not belong to the current sign-in.");
+    return callback;
+}
+export function forwardAntigravityCallback(callback) {
+    return new Promise((resolveForward, reject) => {
+        const req = httpRequest({
+            protocol: "http:",
+            hostname: "127.0.0.1",
+            port: callback.port,
+            path: `${callback.pathname}${callback.search}`,
+            method: "GET",
+            agent: false,
+            timeout: 10_000,
+        }, (response) => {
+            response.resume();
+            response.once("end", () => {
+                const status = response.statusCode ?? 0;
+                if (status >= 200 && status < 300)
+                    resolveForward();
+                else
+                    reject(new Error("Could not deliver the Google sign-in response."));
+            });
+            response.once("error", reject);
+        });
+        req.once("timeout", () => req.destroy(new Error("The Google sign-in response timed out.")));
+        req.once("error", reject);
+        req.end();
+    });
+}
+function modelOptions(value) {
+    if (!Array.isArray(value))
+        return [];
+    const result = [];
+    const seen = new Set();
+    const visit = (entry) => {
+        if (Array.isArray(entry?.options))
+            return entry.options.forEach(visit);
+        const id = typeof entry?.value === "string" ? entry.value : "";
+        if (!id || seen.has(id))
+            return;
+        seen.add(id);
+        result.push({ id, label: typeof entry?.name === "string" && entry.name.trim() ? entry.name.trim() : id });
+    };
+    value.forEach(visit);
+    return result;
+}
+export function catalogFromAntigravityConfigOptions(configOptions, fallbackDefault) {
+    const model = Array.isArray(configOptions)
+        ? configOptions.find((option) => option?.id === "model" && option?.type === "select")
+        : null;
+    const options = modelOptions(model?.options);
+    if (!options.length)
+        return null;
+    const current = typeof model?.currentValue === "string" ? model.currentValue : "";
+    return { default: options.some((option) => option.id === fallbackDefault) ? fallbackDefault : current || options[0].id, options };
+}
+export async function probeAntigravityModels(input) {
+    const deadline = Date.now() + (input.timeoutMs ?? STARTUP_TIMEOUT_MS);
+    const remaining = () => {
+        const milliseconds = deadline - Date.now();
+        if (milliseconds <= 0)
+            throw new Error("Antigravity model discovery timed out.");
+        return milliseconds;
+    };
+    const client = new AntigravityAcpClient(input.runtime, input.profile, input.cwd ?? input.profile.directory);
+    try {
+        await client.initialize(remaining());
+        await client.request("authenticate", { methodId: "oauth-personal" }, remaining());
+        const session = await client.request("session/new", { cwd: input.cwd ?? input.profile.directory, mcpServers: [] }, remaining());
+        const catalog = catalogFromAntigravityConfigOptions(session?.configOptions, input.fallbackDefault);
+        if (!catalog)
+            throw new Error("Antigravity did not return a model catalog for this Google account.");
+        return catalog;
+    }
+    finally {
+        client.close();
+    }
+}
+/**
+ * Validates whether an ACP initialization response matches an official Google Antigravity release.
+ *
+ * @param initialized - The raw initialization response payload returned by the ACP client.
+ * @param expectedVersion - The expected release version tag or semver string.
+ * @returns `true` if the initialize result satisfies protocol, agent identity, capability, and auth requirements.
+ */
+export function isValidAntigravityInitializeResult(initialized, expectedVersion) {
+    if (!initialized || initialized.protocolVersion !== 1)
+        return false;
+    const name = initialized.agentInfo?.name;
+    if (name !== "antigravity-acp" && name !== "Google Antigravity")
+        return false;
+    const actualVersion = initialized.agentInfo?.version;
+    if (typeof actualVersion !== "string")
+        return false;
+    const normalizedActual = actualVersion.replace(/^agy_acp_server_/u, "").trim();
+    const normalizedExpected = expectedVersion.replace(/^agy_acp_server_/u, "").trim();
+    if (actualVersion !== expectedVersion && normalizedActual !== normalizedExpected)
+        return false;
+    // ACP advertises these optional operations as capability objects (including
+    // empty objects). Keep accepting the boolean form used by older runtimes.
+    const advertised = (value) => value === true
+        || (typeof value === "object" && value !== null && !Array.isArray(value));
+    if (initialized.agentCapabilities?.loadSession !== true ||
+        !advertised(initialized.agentCapabilities?.sessionCapabilities?.resume) ||
+        !advertised(initialized.agentCapabilities?.auth?.logout)) {
+        return false;
+    }
+    if (!Array.isArray(initialized.authMethods) || !initialized.authMethods.some((method) => method?.id === "oauth-personal")) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Starts a transient Antigravity ACP client against a temporary profile to verify
+ * that the downloaded runtime binary starts properly and identifies as the expected release.
+ *
+ * @param runtime - The resolved Antigravity executable and harness paths.
+ * @param expectedVersion - The expected version string or tag.
+ * @returns A promise that resolves when verification succeeds, or rejects if initialization fails.
+ */
+export async function validateAntigravityRuntime(runtime, expectedVersion) {
+    const profileDirectory = await mkdtemp(join(tmpdir(), "openmaus-antigravity-verify-"));
+    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.");
+            }
+        }
+        finally {
+            client.close();
+        }
+    }
+    finally {
+        await rm(profileDirectory, { recursive: true, force: true });
+    }
+}
+/** One in-flight personal Google login per provider instance. */
+export class AntigravityAuthController {
+    flow = null;
+    async start(runtime, profile) {
+        this.cancel();
+        let foundUrl;
+        let failUrl;
+        const urlPromise = new Promise((resolveUrl, reject) => {
+            foundUrl = resolveUrl;
+            failUrl = reject;
+        });
+        const client = new AntigravityAcpClient(runtime, profile, profile.directory, (url) => {
+            try {
+                foundUrl(parseAntigravityAuthorizationUrl(url));
+            }
+            catch (error) {
+                failUrl(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+        try {
+            await client.initialize();
+            const authenticated = client.request("authenticate", { methodId: "oauth-personal" }, AUTH_TIMEOUT_MS);
+            let startupTimer;
+            const startupTimeout = new Promise((_resolve, reject) => {
+                startupTimer = setTimeout(() => reject(new Error("Google sign-in did not start in time.")), STARTUP_TIMEOUT_MS);
+                startupTimer.unref?.();
+            });
+            const outcome = await Promise.race([
+                urlPromise.then((request) => ({ kind: "url", request })),
+                authenticated.then(() => ({ kind: "done" })),
+                startupTimeout,
+            ]).finally(() => {
+                if (startupTimer)
+                    clearTimeout(startupTimer);
+            });
+            if (outcome.kind === "done") {
+                client.close();
+                return { phase: "succeeded", flowId: null, authorizationUrl: null, expiresAt: null };
+            }
+            const flow = {
+                id: randomUUID(),
+                client,
+                completed: authenticated,
+                pending: { redirectUri: outcome.request.redirectUri, state: outcome.request.state },
+                expiresAt: Date.now() + AUTH_TIMEOUT_MS,
+            };
+            this.flow = flow;
+            void authenticated.finally(() => {
+                if (this.flow === flow)
+                    this.flow = null;
+                client.close();
+            }).catch(() => { });
+            return {
+                phase: "waiting",
+                flowId: flow.id,
+                authorizationUrl: outcome.request.authorizationUrl,
+                expiresAt: new Date(flow.expiresAt).toISOString(),
+            };
+        }
+        catch (error) {
+            client.close();
+            throw error;
+        }
+    }
+    async complete(flowId, callbackUrl) {
+        const flow = this.flow;
+        if (!flow || flow.id !== flowId || Date.now() >= flow.expiresAt) {
+            throw new Error("This Google sign-in is no longer active. Start again.");
+        }
+        await forwardAntigravityCallback(validateAntigravityCallbackUrl(flow.pending, callbackUrl));
+        await flow.completed;
+    }
+    cancel() {
+        this.flow?.client.close();
+        this.flow = null;
+    }
+}

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

@@ -0,0 +1,65 @@
+// URLs come from Google's official ACP registry entry. Hashes and expanded
+// member sizes were checked independently in T3 Code on 2026-09-03.
+// Registry: agentclientprotocol/registry@81bf71b55e15f630c4fb8a86d20d3088071d2071
+// Metadata: pingdotgg/t3code@8ea52c8f2
+export const ANTIGRAVITY_RELEASE_VERSION = "agy_acp_server_1.1.1";
+const RELEASES = new Map([
+    [
+        "darwin-arm64",
+        {
+            version: ANTIGRAVITY_RELEASE_VERSION,
+            url: "https://dl.google.com/agy-extensions/releases/macos/agy-acp-server-agy_acp_server_1.1.1-darwin-arm64.zip",
+            sha256: "fdfa915652cdb7ba8085cc8fffed072cbe009251aa2c951aabdda07a8c28a189",
+            archiveBytes: 316_014_828,
+            executable: { name: "agy_acp_server.par", bytes: 802_163_856 },
+            harness: { name: "localharness_external", bytes: 116_766_704 },
+        },
+    ],
+    [
+        "linux-x64",
+        {
+            version: ANTIGRAVITY_RELEASE_VERSION,
+            url: "https://dl.google.com/agy-extensions/releases/linux/agy-acp-server-agy_acp_server_1.1.1-linux-x86_64.zip",
+            sha256: "38f62d01b32deb0907b3d39a71ec301fd36369f6ffd1cf262d4af385177f79df",
+            archiveBytes: 681_969_407,
+            executable: { name: "agy_acp_server.par", bytes: 1_880_360_328 },
+            harness: { name: "localharness_external", bytes: 128_966_920 },
+        },
+    ],
+    [
+        "linux-arm64",
+        {
+            version: ANTIGRAVITY_RELEASE_VERSION,
+            url: "https://dl.google.com/agy-extensions/releases/linux/agy-acp-server-agy_acp_server_1.1.1-linux-arm64.zip",
+            sha256: "ed69e64b308fcb123ab54bf3277bf9cb0d651064f885ea5aab0ff520c7175398",
+            archiveBytes: 656_572_786,
+            executable: { name: "agy_acp_server.par", bytes: 1_862_073_131 },
+            harness: { name: "localharness_external", bytes: 122_158_704 },
+        },
+    ],
+    [
+        "win32-x64",
+        {
+            version: ANTIGRAVITY_RELEASE_VERSION,
+            url: "https://dl.google.com/agy-extensions/releases/windows/agy-acp-server-agy_acp_server_1.1.1-windows-x86_64.zip",
+            sha256: "47cb50eef14f0a4655d78cfcfda869bcea7aaee5f9787e936bc2935ea612c3b8",
+            archiveBytes: 468_238_392,
+            executable: { name: "agy_acp_server.exe", bytes: 430_801_616 },
+            harness: { name: "localharness_external.exe", bytes: 130_971_800 },
+        },
+    ],
+    [
+        "win32-arm64",
+        {
+            version: ANTIGRAVITY_RELEASE_VERSION,
+            url: "https://dl.google.com/agy-extensions/releases/windows/agy-acp-server-agy_acp_server_1.1.1-windows-arm64.zip",
+            sha256: "35f4b1f47ba6a3fea7b0a3e30010df5ea73a64b4f0e7cf991cddc673ddfbcafc",
+            archiveBytes: 468_521_191,
+            executable: { name: "agy_acp_server.exe", bytes: 435_075_816 },
+            harness: { name: "localharness_external.exe", bytes: 122_455_704 },
+        },
+    ],
+]);
+export function resolveAntigravityReleaseAsset(platform = process.platform, arch = process.arch) {
+    return RELEASES.get(`${platform}-${arch}`) ?? null;
+}