openmausbot 0.1.55

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

@@ -0,0 +1,395 @@
+import { createHash, randomUUID } from "node:crypto";
+import { createReadStream, createWriteStream } from "node:fs";
+import { access, chmod, mkdir, mkdtemp, open, readFile, rename, rm, stat, statfs, writeFile, } from "node:fs/promises";
+import { constants } from "node:fs";
+import { delimiter, dirname, isAbsolute, join, resolve } from "node:path";
+import { Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { createInflateRaw } from "node:zlib";
+import { DATA_DIR } from "../config.js";
+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 INSTALL_RECORD = ".install-complete.json";
+export class AntigravitySetupError extends Error {
+    status = 409;
+    constructor(message) {
+        super(message);
+        this.name = "AntigravitySetupError";
+    }
+}
+const installs = new Map();
+function runtimeRoot(baseDir = DATA_DIR) {
+    return join(baseDir, "tools", "antigravity-acp", `${process.platform}-${process.arch}`);
+}
+function executableNames(platform = process.platform) {
+    return platform === "win32"
+        ? { executable: "agy_acp_server.exe", harness: "localharness_external.exe" }
+        : { executable: "agy_acp_server.par", harness: "localharness_external" };
+}
+async function executableFile(path, bytes) {
+    try {
+        const info = await stat(path);
+        if (!info.isFile() || (bytes !== undefined && info.size !== bytes))
+            return false;
+        if (process.platform !== "win32")
+            await access(path, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function completedRelease(directory, asset) {
+    try {
+        const record = JSON.parse(await readFile(join(directory, INSTALL_RECORD), "utf8"));
+        if (record.sha256 !== asset.sha256 ||
+            record.version !== asset.version ||
+            record.executable.name !== asset.executable.name ||
+            record.executable.bytes !== asset.executable.bytes ||
+            record.harness.name !== asset.harness.name ||
+            record.harness.bytes !== asset.harness.bytes)
+            return null;
+        const executablePath = join(directory, asset.executable.name);
+        const harnessPath = join(directory, asset.harness.name);
+        if (!(await executableFile(executablePath, asset.executable.bytes)))
+            return null;
+        if (!(await executableFile(harnessPath, asset.harness.bytes)))
+            return null;
+        return { executablePath, harnessPath, source: "managed", version: asset.version };
+    }
+    catch {
+        return null;
+    }
+}
+function pathCandidates(binary, env) {
+    if (isAbsolute(binary) || binary.includes("/") || binary.includes("\\"))
+        return [resolve(binary)];
+    const pathValue = process.platform === "win32"
+        ? Object.entries(env).findLast(([key]) => key.toUpperCase() === "PATH")?.[1]
+        : env.PATH;
+    return (pathValue ?? augmentedPath())
+        .split(delimiter)
+        .map((part) => part.trim().replace(/^"|"$/gu, ""))
+        .filter(Boolean)
+        .map((part) => resolve(part, binary));
+}
+async function externalRuntime(candidate, source) {
+    const names = executableNames();
+    const executablePath = resolve(candidate);
+    const harnessPath = join(dirname(executablePath), names.harness);
+    if (!(await executableFile(executablePath)) || !(await executableFile(harnessPath)))
+        return null;
+    return { executablePath, harnessPath, source, version: null };
+}
+/** Resolve an explicit official ACP binary, the pinned managed release, or an
+ * official binary already on PATH. Legacy `agy` commands (including saved
+ * absolute paths and Windows shims) migrate without editing user config. */
+export async function resolveAntigravityRuntime(binaryPath, env = process.env, baseDir = DATA_DIR) {
+    const override = binaryPath?.trim();
+    const legacyCli = override !== undefined && /(?:^|[\\/])agy(?:\.(?:cmd|bat|exe|ps1))?$/iu.test(override);
+    if (override && override !== "agy") {
+        for (const candidate of pathCandidates(override, env)) {
+            const found = await externalRuntime(candidate, "override");
+            if (found)
+                return found;
+        }
+        // Older versions saved the detected agy path in engine settings. It is
+        // not an official ACP override: installing the new runtime must not leave
+        // discovery permanently stuck on that legacy command. A valid explicit
+        // ACP executable still wins above, regardless of its filename.
+        if (!legacyCli) {
+            throw new AntigravitySetupError("The custom Antigravity ACP executable or its localharness_external sibling is missing.");
+        }
+    }
+    const asset = resolveAntigravityReleaseAsset();
+    if (asset) {
+        const managed = await completedRelease(join(runtimeRoot(baseDir), "versions", asset.sha256), asset);
+        if (managed)
+            return managed;
+    }
+    const names = executableNames();
+    for (const candidate of pathCandidates(names.executable, env)) {
+        const found = await externalRuntime(candidate, "path");
+        if (found)
+            return found;
+    }
+    if (!asset) {
+        throw new AntigravitySetupError(`Google does not publish an Antigravity runtime for ${process.platform}-${process.arch}. Set a custom executable path.`);
+    }
+    throw new AntigravitySetupError(legacyCli
+        ? "Antigravity now uses Google's official runtime. Choose Install official Antigravity, then Sign in with Google. Your previous agy login is not copied."
+        : "Antigravity is not installed. Install the official Google runtime to continue.");
+}
+const EOCD_SIGNATURE = 0x06054b50;
+const CENTRAL_SIGNATURE = 0x02014b50;
+const LOCAL_SIGNATURE = 0x04034b50;
+const MAX_EOCD_BYTES = 22 + 0xffff;
+/** Read the ZIP directory without loading Google's 300 MiB archive (or its
+ * 1.5 GiB expanded binary) into memory. The whole archive is SHA-pinned first;
+ * this parser only accepts the exact two flat members named by the manifest. */
+async function pinnedZipEntries(path) {
+    const handle = await open(path, "r");
+    try {
+        const info = await handle.stat();
+        const tailBytes = Math.min(info.size, MAX_EOCD_BYTES);
+        const tail = Buffer.alloc(tailBytes);
+        const tailOffset = info.size - tailBytes;
+        if ((await handle.read(tail, 0, tailBytes, tailOffset)).bytesRead !== tailBytes) {
+            throw new Error("The verified archive was truncated.");
+        }
+        let eocd = -1;
+        for (let cursor = tail.length - 22; cursor >= 0; cursor -= 1) {
+            if (tail.readUInt32LE(cursor) === EOCD_SIGNATURE
+                && cursor + 22 + tail.readUInt16LE(cursor + 20) === tail.length) {
+                eocd = cursor;
+                break;
+            }
+        }
+        if (eocd < 0)
+            throw new Error("The verified archive has no valid ZIP directory.");
+        const disk = tail.readUInt16LE(eocd + 4);
+        const directoryDisk = tail.readUInt16LE(eocd + 6);
+        const diskEntries = tail.readUInt16LE(eocd + 8);
+        const entryCount = tail.readUInt16LE(eocd + 10);
+        const directoryBytes = tail.readUInt32LE(eocd + 12);
+        const directoryOffset = tail.readUInt32LE(eocd + 16);
+        const eocdOffset = tailOffset + eocd;
+        if (disk !== 0 || directoryDisk !== 0 || diskEntries !== entryCount || entryCount !== 2
+            || directoryBytes === 0xffffffff || directoryOffset === 0xffffffff
+            || directoryOffset + directoryBytes > eocdOffset)
+            throw new Error("The verified archive uses an unsupported ZIP layout.");
+        const directory = Buffer.alloc(directoryBytes);
+        if ((await handle.read(directory, 0, directoryBytes, directoryOffset)).bytesRead !== directoryBytes) {
+            throw new Error("The verified archive directory was truncated.");
+        }
+        const entries = [];
+        let cursor = 0;
+        while (cursor < directory.length) {
+            if (cursor + 46 > directory.length || directory.readUInt32LE(cursor) !== CENTRAL_SIGNATURE) {
+                throw new Error("The verified archive directory is invalid.");
+            }
+            const flags = directory.readUInt16LE(cursor + 8);
+            const compression = directory.readUInt16LE(cursor + 10);
+            const compressedBytes = directory.readUInt32LE(cursor + 20);
+            const uncompressedBytes = directory.readUInt32LE(cursor + 24);
+            const nameBytes = directory.readUInt16LE(cursor + 28);
+            const extraBytes = directory.readUInt16LE(cursor + 30);
+            const commentBytes = directory.readUInt16LE(cursor + 32);
+            const startDisk = directory.readUInt16LE(cursor + 34);
+            const externalAttributes = directory.readUInt32LE(cursor + 38);
+            const localHeaderOffset = directory.readUInt32LE(cursor + 42);
+            const next = cursor + 46 + nameBytes + extraBytes + commentBytes;
+            if (next > directory.length || startDisk !== 0 || (flags & 1) !== 0
+                || (compression !== 0 && compression !== 8)
+                || compressedBytes === 0xffffffff || uncompressedBytes === 0xffffffff
+                || localHeaderOffset === 0xffffffff)
+                throw new Error("The verified archive contains an unsupported ZIP member.");
+            entries.push({
+                name: directory.subarray(cursor + 46, cursor + 46 + nameBytes).toString("utf8"),
+                compression,
+                compressedBytes,
+                uncompressedBytes,
+                localHeaderOffset,
+                externalAttributes,
+            });
+            cursor = next;
+        }
+        if (entries.length !== entryCount)
+            throw new Error("The verified archive member count is invalid.");
+        return entries;
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function zipEntryDataOffset(path, entry) {
+    const handle = await open(path, "r");
+    try {
+        const header = Buffer.alloc(30);
+        if ((await handle.read(header, 0, header.length, entry.localHeaderOffset)).bytesRead !== header.length) {
+            throw new Error("A verified archive member header was truncated.");
+        }
+        const nameBytes = header.readUInt16LE(26);
+        const extraBytes = header.readUInt16LE(28);
+        if (header.readUInt32LE(0) !== LOCAL_SIGNATURE
+            || header.readUInt16LE(8) !== entry.compression
+            || (header.readUInt16LE(6) & 1) !== 0)
+            throw new Error("A verified archive member header is invalid.");
+        const name = Buffer.alloc(nameBytes);
+        if ((await handle.read(name, 0, nameBytes, entry.localHeaderOffset + 30)).bytesRead !== nameBytes) {
+            throw new Error("A verified archive member name was truncated.");
+        }
+        if (name.toString("utf8") !== entry.name)
+            throw new Error("A verified archive member name did not match its directory.");
+        return entry.localHeaderOffset + 30 + nameBytes + extraBytes;
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function extractPinnedArchive(archivePath, outputDirectory, asset) {
+    const expected = new Map([
+        [asset.executable.name, asset.executable.bytes],
+        [asset.harness.name, asset.harness.bytes],
+    ]);
+    const seen = new Set();
+    for (const entry of await pinnedZipEntries(archivePath)) {
+        const expectedBytes = expected.get(entry.name);
+        const unixType = (entry.externalAttributes >>> 16) & 0o170000;
+        if (expectedBytes === undefined || seen.has(entry.name)
+            || entry.name.includes("/") || entry.name.includes("\\")
+            || (unixType !== 0 && unixType !== 0o100000)
+            || entry.uncompressedBytes !== expectedBytes || entry.compressedBytes <= 0)
+            throw new Error("The archive contains an unexpected or unsafe file.");
+        seen.add(entry.name);
+        const dataOffset = await zipEntryDataOffset(archivePath, entry);
+        let bytes = 0;
+        const counter = new Transform({
+            transform(chunk, _encoding, callback) {
+                bytes += chunk.length;
+                callback(bytes <= expectedBytes ? null : new Error("An extracted file exceeded its pinned size."), chunk);
+            },
+        });
+        const source = createReadStream(archivePath, {
+            start: dataOffset,
+            end: dataOffset + entry.compressedBytes - 1,
+        });
+        const destination = createWriteStream(join(outputDirectory, entry.name), { flags: "wx", mode: 0o700 });
+        if (entry.compression === 8)
+            await pipeline(source, createInflateRaw(), counter, destination);
+        else
+            await pipeline(source, counter, destination);
+        if (bytes !== expectedBytes)
+            throw new Error("An extracted file was truncated.");
+    }
+    if (seen.size !== 2)
+        throw new Error("The archive is missing an expected file.");
+}
+async function installOnce(options) {
+    const asset = options.asset === undefined ? resolveAntigravityReleaseAsset() : options.asset;
+    if (!asset)
+        throw new Error(`Google does not publish an Antigravity runtime for ${process.platform}-${process.arch}.`);
+    const root = runtimeRoot(options.baseDir);
+    const versions = join(root, "versions");
+    const destination = join(versions, asset.sha256);
+    await mkdir(versions, { recursive: true, mode: 0o700 });
+    const existing = await completedRelease(destination, asset);
+    if (existing) {
+        await options.validate?.(existing, asset.version);
+        return existing;
+    }
+    try {
+        const disk = await statfs(versions, { bigint: true });
+        const required = BigInt(asset.archiveBytes + asset.executable.bytes + asset.harness.bytes + FREE_SPACE_MARGIN);
+        if (disk.bavail * disk.bsize < required) {
+            throw new Error(`Antigravity needs at least ${Math.ceil(Number(required) / 1024 / 1024)} MiB of free space to install.`);
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes("Antigravity needs"))
+            throw error;
+        // 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()}-`));
+    try {
+        const archivePath = join(staging, "download.zip");
+        const runtimeDirectory = join(staging, "runtime");
+        await mkdir(runtimeDirectory, { mode: 0o700 });
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), DOWNLOAD_TIMEOUT_MS);
+        timeout.unref?.();
+        try {
+            const response = await (options.fetchImpl ?? fetch)(asset.url, { signal: controller.signal, redirect: "follow" });
+            if (!response.ok || !response.body)
+                throw new Error(`Google download failed (${response.status}).`);
+            const finalUrl = new URL(response.url || asset.url);
+            if (finalUrl.protocol !== "https:" || finalUrl.hostname !== "dl.google.com") {
+                throw new Error("The Antigravity download redirected outside dl.google.com.");
+            }
+            const encoding = response.headers.get("content-encoding")?.trim().toLowerCase();
+            const length = response.headers.get("content-length");
+            if ((!encoding || encoding === "identity") && length && Number(length) !== asset.archiveBytes) {
+                throw new Error("The Antigravity download size did not match the pinned release.");
+            }
+            const handle = await open(archivePath, "wx", 0o600);
+            const hash = createHash("sha256");
+            let downloaded = 0;
+            try {
+                for await (const raw of response.body) {
+                    const chunk = Buffer.from(raw);
+                    if (downloaded + chunk.length > asset.archiveBytes) {
+                        throw new Error("The Antigravity download exceeded its pinned size.");
+                    }
+                    let offset = 0;
+                    while (offset < chunk.length) {
+                        const { bytesWritten } = await handle.write(chunk, offset, chunk.length - offset, null);
+                        if (bytesWritten <= 0)
+                            throw new Error("The Antigravity download could not be written completely.");
+                        offset += bytesWritten;
+                    }
+                    hash.update(chunk);
+                    downloaded += chunk.length;
+                }
+            }
+            finally {
+                await handle.close();
+            }
+            if (downloaded !== asset.archiveBytes || hash.digest("hex") !== asset.sha256) {
+                throw new Error("The Antigravity download failed its SHA-256 or size check. Nothing was installed.");
+            }
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+        await extractPinnedArchive(archivePath, runtimeDirectory, asset);
+        if (process.platform !== "win32") {
+            await chmod(join(runtimeDirectory, asset.executable.name), 0o755);
+            await chmod(join(runtimeDirectory, asset.harness.name), 0o755);
+        }
+        const candidate = {
+            executablePath: join(runtimeDirectory, asset.executable.name),
+            harnessPath: join(runtimeDirectory, asset.harness.name),
+            source: "managed",
+            version: asset.version,
+        };
+        await options.validate?.(candidate, asset.version);
+        const record = {
+            sha256: asset.sha256,
+            version: asset.version,
+            executable: asset.executable,
+            harness: asset.harness,
+        };
+        await writeFile(join(runtimeDirectory, INSTALL_RECORD), `${JSON.stringify(record)}\n`, { flag: "wx", mode: 0o600 });
+        try {
+            await rename(runtimeDirectory, destination);
+        }
+        catch (error) {
+            const winner = await completedRelease(destination, asset);
+            if (!winner)
+                throw error;
+        }
+        const installed = await completedRelease(destination, asset);
+        if (!installed)
+            throw new Error("The installed Antigravity runtime is incomplete.");
+        return installed;
+    }
+    finally {
+        await rm(staging, { recursive: true, force: true });
+    }
+}
+/** Coalesce concurrent clicks so only one large Google artifact is fetched. */
+export function installAntigravityRuntime(options = {}) {
+    const key = runtimeRoot(options.baseDir);
+    const existing = installs.get(key);
+    if (existing)
+        return existing;
+    const running = installOnce(options).finally(() => installs.delete(key));
+    installs.set(key, running);
+    return running;
+}
+export function antigravityManagedInstallAvailable() {
+    return resolveAntigravityReleaseAsset() !== null;
+}

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

@@ -0,0 +1,144 @@
+import { createAcpDriver } from "./acp/core.js";
+import { AntigravityAuthController, antigravityProfileAuthenticated, catalogFromAntigravityConfigOptions, prepareAntigravityProfile, probeAntigravityModels, validateAntigravityRuntime, } from "./antigravity-acp.js";
+import { antigravityManagedInstallAvailable, installAntigravityRuntime, resolveAntigravityRuntime, } from "./antigravity-runtime.js";
+import { resolveAntigravityReleaseAsset } from "./antigravity-release.js";
+export const STATIC_ANTIGRAVITY_MODELS = {
+    default: "gemini-3.8-flash-high",
+    options: [
+        { id: "gemini-3.8-flash-high", label: "Gemini 3.8 Flash (High)" },
+        { id: "gemini-3.8-flash-medium", label: "Gemini 3.8 Flash (Medium)" },
+        { id: "gemini-3.8-flash-low", label: "Gemini 3.8 Flash (Low)" },
+    ],
+};
+export function antigravityPermissionMode(fullAuto) {
+    return fullAuto ? "yolo" : "default";
+}
+export function antigravityModelsFromSession(value) {
+    return catalogFromAntigravityConfigOptions(value, STATIC_ANTIGRAVITY_MODELS.default);
+}
+const managedAsset = resolveAntigravityReleaseAsset();
+const support = {
+    driverKind: "antigravityAgent",
+    displayName: "Antigravity",
+    models: STATIC_ANTIGRAVITY_MODELS,
+    defaultCli: "agy", // migration alias: resolveAntigravityRuntime treats it as managed
+    nativeSource: "antigravity.acp",
+    loginNote: "Antigravity needs a Google account — choose Sign in with Google in engine setup",
+    install: {
+        docsUrl: "https://github.com/agentclientprotocol/registry/tree/main/antigravity-acp",
+        ...(managedAsset
+            ? { managed: { label: "Install official Antigravity", downloadBytes: managedAsset.archiveBytes } }
+            : {}),
+    },
+    images: true,
+    spawnArgs: () => [],
+    selectModel: { configId: "model" },
+    resumeMethod: "resume",
+    clientFileSystem: true,
+    redactStderr: true,
+    sanitizeToolPayload: true,
+    resolveModelsOnCreate: false,
+    resolveCommand: async (env, config, instanceId) => {
+        const runtime = await resolveAntigravityRuntime(config.cli, env);
+        const profile = await prepareAntigravityProfile({ instanceId, runtime, baseEnv: env });
+        return {
+            command: runtime.executablePath,
+            args: process.platform === "linux" ? ["--uid="] : [],
+            env: profile.environment,
+        };
+    },
+    resolveModels: async (env, config, instanceId) => {
+        const runtime = await resolveAntigravityRuntime(config.cli, env);
+        const profile = await prepareAntigravityProfile({ instanceId, runtime, baseEnv: env });
+        if (!(await antigravityProfileAuthenticated(profile)))
+            throw new Error(support.loginNote);
+        return probeAntigravityModels({
+            runtime,
+            profile,
+            fallbackDefault: STATIC_ANTIGRAVITY_MODELS.default,
+        });
+    },
+    pickAuthMethod: (methods) => methods.some((method) => method.id === "oauth-personal")
+        ? "oauth-personal"
+        : null,
+    authFailure: "fail",
+    requireAuthenticationBeforeSpawn: true,
+    isAuthenticated: async (env, config, instanceId) => {
+        try {
+            const runtime = await resolveAntigravityRuntime(config.cli, env);
+            const profile = await prepareAntigravityProfile({ instanceId, runtime, baseEnv: env });
+            return antigravityProfileAuthenticated(profile);
+        }
+        catch {
+            return false;
+        }
+    },
+    snapshot: async (env, config, instanceId) => {
+        try {
+            const runtime = await resolveAntigravityRuntime(config.cli, env);
+            const profile = await prepareAntigravityProfile({ instanceId, runtime, baseEnv: env });
+            return {
+                state: "available",
+                version: runtime.version,
+                authenticated: await antigravityProfileAuthenticated(profile),
+            };
+        }
+        catch (error) {
+            return { state: "unavailable", reason: error instanceof Error ? error.message : String(error) };
+        }
+    },
+    configureSession: async ({ request, sessionId, config }) => {
+        const wanted = antigravityPermissionMode(config.fullAuto);
+        const result = await request("session/set_config_option", {
+            sessionId,
+            configId: "mode",
+            value: wanted,
+        });
+        const mode = Array.isArray(result?.configOptions)
+            ? result.configOptions.find((option) => option?.id === "mode")?.currentValue
+            : undefined;
+        if (mode !== wanted)
+            throw new Error(`Antigravity did not apply ${wanted} permission mode.`);
+    },
+};
+const AcpAntigravityDriver = createAcpDriver(support);
+export const AntigravityDriver = {
+    ...AcpAntigravityDriver,
+    async create(input) {
+        const base = await AcpAntigravityDriver.create(input);
+        const auth = new AntigravityAuthController();
+        const runtimeAndProfile = async () => {
+            const environment = { ...process.env, ...input.environment };
+            const runtime = await resolveAntigravityRuntime(input.config.cli, environment);
+            const profile = await prepareAntigravityProfile({
+                instanceId: input.instanceId,
+                runtime,
+                baseEnv: environment,
+            });
+            return { runtime, profile };
+        };
+        return {
+            ...base,
+            get models() {
+                return base.models;
+            },
+            ...(antigravityManagedInstallAvailable()
+                ? {
+                    installRuntime: async () => {
+                        await installAntigravityRuntime({ validate: validateAntigravityRuntime });
+                    },
+                }
+                : {}),
+            startAuthentication: async () => {
+                const { runtime, profile } = await runtimeAndProfile();
+                return auth.start(runtime, profile);
+            },
+            completeAuthentication: async (flowId, callbackUrl) => auth.complete(flowId, callbackUrl),
+            cancelAuthentication: async () => auth.cancel(),
+            dispose: async () => {
+                auth.cancel();
+                await base.dispose();
+            },
+        };
+    },
+};