openmausbot 0.1.55

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

@@ -0,0 +1,95 @@
+// Gemini CLI harness support — Google's `gemini` CLI over ACP stdio
+// (`gemini --acp`). Rides the generic runtime in acp/core.ts.
+//
+// RETIRED FROM THE DEFAULT FLEET: Google stopped serving Gemini CLI requests
+// for the free/Pro/Ultra tiers on 2026-06-18 and pointed everyone at the
+// Antigravity CLI (see drivers/antigravity.ts), so this only reaches a model
+// on an enterprise licence. Kept registered for exactly that case — add
+// {"instances": {"gemini": {"driver": "geminiAgent"}}} to config.json.
+//
+// Auth reality since 2026-06-18 (#28): consumer "Login with Google" no
+// longer serves the Gemini CLI — consumer tiers route through Antigravity,
+// and the login that produced ~/.gemini/oauth_creds.json stopped working
+// for them. The remaining paths are a GEMINI_API_KEY, Vertex, or an
+// enterprise Code Assist licence (whose OAuth refresh still works). The
+// driver cannot tell a consumer from an enterprise file locally, so the
+// file check only counts a *live-looking* credential (unexpired access
+// token, or a refresh token the CLI may still be able to use) and the
+// login note names the three real paths instead of the retired login.
+//
+// Auth is intentionally lenient (authFailure "continue"): the CLI may run
+// off an ambient login, so we attempt the advertised authenticate method
+// but never hard-fail the turn on it, unlike Grok's subscription-bound
+// cached_token.
+//
+// NOTE: untested against a live `gemini` CLI on this machine (not installed);
+// the ACP flag + auth method ids follow the published Gemini CLI ACP contract
+// and should be re-verified end-to-end once the CLI is present.
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { createAcpDriver } from "./core.js";
+// Prefer an explicit key method, then personal OAuth, then Vertex — but fall
+// back to whatever the CLI advertises so a new method id still works.
+const AUTH_PREFERENCE = ["gemini-api-key", "oauth-personal", "vertex-ai"];
+/** A stored oauth_creds.json only counts when it looks alive: the access
+ * token has not passed its expiry_date, or a refresh token is present that
+ * an enterprise licence may still redeem. A stale consumer credential —
+ * the common case since 2026-06-18 — reads as not signed in, which is the
+ * truthful answer for an engine that would fail its first turn anyway. */
+function liveOauthCredential() {
+    try {
+        const creds = JSON.parse(readFileSync(join(homedir(), ".gemini", "oauth_creds.json"), "utf8"));
+        if (typeof creds.access_token !== "string" || creds.access_token.trim().length === 0)
+            return false;
+        const hasRefresh = typeof creds.refresh_token === "string" && creds.refresh_token.trim().length > 0;
+        if (creds.expiry_date !== undefined) {
+            if (typeof creds.expiry_date !== "number" || !Number.isFinite(creds.expiry_date))
+                return false;
+            return Date.now() < creds.expiry_date || hasRefresh;
+        }
+        // no recorded expiry — treat possession of the credential as the signal
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const nonBlank = (value) => Boolean(value?.trim());
+/** The credential check as a named function, so the support entry and the
+ * exported test surface are the same implementation, not a self-call.
+ * Config is unused — kept to match the AcpSupport signature. */
+export function geminiIsAuthenticated(env) {
+    return (nonBlank(env.GEMINI_API_KEY) ||
+        nonBlank(env.GOOGLE_API_KEY) ||
+        (existsSync(join(homedir(), ".gemini", "oauth_creds.json")) && liveOauthCredential()));
+}
+const support = {
+    driverKind: "geminiAgent",
+    displayName: "Gemini",
+    models: {
+        default: "gemini-2.5-pro",
+        options: [
+            { id: "gemini-2.5-pro", label: "Gemini 2.5 Pro" },
+            { id: "gemini-2.5-flash", label: "Gemini 2.5 Flash" },
+        ],
+    },
+    defaultCli: "gemini",
+    nativeSource: "gemini.acp",
+    loginNote: "Gemini CLI needs a GEMINI_API_KEY, a Vertex AI setup, or an enterprise Code Assist login — consumer Google logins stopped working on 2026-06-18 (use the Antigravity engine for those accounts)",
+    // --acp is the stable Gemini CLI surface. --experimental-acp remains an
+    // alias for older releases, but using it now emits a deprecation warning.
+    spawnArgs: (_config, turn) => ["--acp", ...(turn.model ? ["-m", turn.model] : [])],
+    credentialEnv: ["GEMINI_API_KEY", "GOOGLE_API_KEY"],
+    pickAuthMethod: (methods) => {
+        const ids = methods.map((m) => m.id).filter((id) => typeof id === "string");
+        for (const pref of AUTH_PREFERENCE)
+            if (ids.includes(pref))
+                return pref;
+        return ids[0] ?? null;
+    },
+    authFailure: "continue",
+    isAuthenticated: geminiIsAuthenticated,
+    buildPromptText: (turn) => (turn.system ? `${turn.system}\n\n${turn.text}` : turn.text),
+};
+export const GeminiAgentDriver = createAcpDriver(support);

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

@@ -0,0 +1,249 @@
+// Grok Build harness support — the official `grok` CLI over ACP stdio
+// (`grok … agent stdio`), on the grok.com subscription login
+// (~/.grok/auth.json), NOT the xAI API key (that driver is drivers/grok.ts).
+// The generic protocol runtime lives in acp/core.ts; this file is only the
+// per-harness quirks. Verified against grok 1.0.0.
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { decodeInjectId, hostApiKey, localHost, mergeLocalInject } from "../local-inject.js";
+import { createAcpDriver } from "./core.js";
+export const STATIC_GROK_MODELS = {
+    default: "grok-4.6",
+    options: [
+        { id: "grok-4.6", label: "Grok 4.6" },
+        { id: "grok-4.5", label: "Grok 4.5" },
+    ],
+};
+const SLUG = /^[a-z0-9][a-z0-9._-]*$/i;
+function grokHome(env) {
+    if (env.GROK_HOME)
+        return env.GROK_HOME;
+    return join(env.HOME || env.USERPROFILE || homedir(), ".grok");
+}
+function unquote(raw) {
+    const value = raw.trim();
+    if (value.length >= 2 && value.startsWith('"') && value.endsWith('"')) {
+        return value.slice(1, -1).replace(/\\"/g, '"');
+    }
+    return value;
+}
+/** Local slugs from ~/.grok/config.toml, plus the two cloud defaults.
+ *  `grok -m <slug>` already accepts these; the picker just didn't list them. */
+export function readGrokModelCatalog(env = process.env) {
+    const path = join(grokHome(env), "config.toml");
+    let text = "";
+    try {
+        text = readFileSync(path, "utf8");
+    }
+    catch {
+        return STATIC_GROK_MODELS;
+    }
+    const options = STATIC_GROK_MODELS.options.map((o) => ({ ...o }));
+    const seen = new Set(options.map((o) => o.id));
+    let configuredDefault = null;
+    let current = null;
+    let inModels = false;
+    const flush = () => {
+        if (!current || !SLUG.test(current.slug) || seen.has(current.slug)) {
+            current = null;
+            return;
+        }
+        seen.add(current.slug);
+        options.push({ id: current.slug, label: current.name || current.slug, custom: true });
+        current = null;
+    };
+    for (const line of text.split(/\r?\n/)) {
+        const stripped = line.trim();
+        if (stripped === "[models]") {
+            flush();
+            inModels = true;
+            continue;
+        }
+        if (stripped.startsWith("[model.") && stripped.endsWith("]")) {
+            flush();
+            inModels = false;
+            let inner = stripped.slice("[model.".length, -1);
+            if (inner.startsWith('"') && inner.endsWith('"'))
+                inner = inner.slice(1, -1);
+            current = { slug: inner };
+            continue;
+        }
+        if (stripped.startsWith("[")) {
+            flush();
+            inModels = false;
+            continue;
+        }
+        if (!stripped || stripped.startsWith("#") || !stripped.includes("="))
+            continue;
+        const eq = stripped.indexOf("=");
+        const key = stripped.slice(0, eq).trim();
+        const value = unquote(stripped.slice(eq + 1));
+        if (current && key === "name" && value)
+            current.name = value;
+        if (!current && inModels && key === "default")
+            configuredDefault = value;
+    }
+    flush();
+    return {
+        default: configuredDefault && seen.has(configuredDefault) ? configuredDefault : STATIC_GROK_MODELS.default,
+        options,
+    };
+}
+function suggestGrokSlug(host, model, taken) {
+    let base = `${host}-${model}`.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+    if (!base || !/^[a-z]/.test(base))
+        base = `m-${base || "model"}`;
+    let slug = base;
+    let n = 2;
+    while (taken.has(slug)) {
+        slug = `${base}-${n}`;
+        n += 1;
+    }
+    return slug;
+}
+function quoteToml(value) {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+/** Write a [model.slug] block so `grok -m` can reach the injected host. */
+export function ensureGrokInjectSlug(modelId, env = process.env) {
+    const inject = decodeInjectId(modelId);
+    if (!inject)
+        return modelId;
+    const host = localHost(inject.host);
+    if (!host)
+        return modelId;
+    const path = join(grokHome(env), "config.toml");
+    let text = "";
+    try {
+        text = readFileSync(path, "utf8");
+    }
+    catch {
+        text = "";
+    }
+    const taken = new Set(STATIC_GROK_MODELS.options.map((option) => option.id));
+    let current = null;
+    const flush = () => {
+        if (!current)
+            return;
+        taken.add(current.slug);
+        if (current.model === inject.model && current.baseUrl === host.baseUrl) {
+            found = current.slug;
+        }
+        current = null;
+    };
+    let found = null;
+    for (const line of text.split(/\r?\n/)) {
+        const stripped = line.trim();
+        if (stripped.startsWith("[model.") && stripped.endsWith("]")) {
+            flush();
+            let inner = stripped.slice("[model.".length, -1);
+            if (inner.startsWith('"') && inner.endsWith('"'))
+                inner = inner.slice(1, -1);
+            current = { slug: inner };
+            continue;
+        }
+        if (stripped.startsWith("[")) {
+            flush();
+            continue;
+        }
+        if (!current || !stripped.includes("="))
+            continue;
+        const eq = stripped.indexOf("=");
+        const key = stripped.slice(0, eq).trim();
+        const value = unquote(stripped.slice(eq + 1));
+        if (key === "model")
+            current.model = value;
+        if (key === "base_url")
+            current.baseUrl = value;
+    }
+    flush();
+    if (found)
+        return found;
+    const slug = suggestGrokSlug(inject.host, inject.model, taken);
+    const heading = /[^a-z0-9_-]/i.test(slug) ? `[model."${slug}"]` : `[model.${slug}]`;
+    const block = [
+        heading,
+        `model = ${quoteToml(inject.model)}`,
+        `base_url = ${quoteToml(host.baseUrl)}`,
+        `name = ${quoteToml(`${inject.model} (${host.label})`)}`,
+        `api_backend = "chat_completions"`,
+        `api_key = ${quoteToml(hostApiKey(host, env))}`,
+        "",
+    ].join("\n");
+    const next = text && !text.endsWith("\n") ? `${text}\n\n${block}` : `${text}${text ? "\n" : ""}${block}`;
+    writeFileSync(path, next);
+    return slug;
+}
+const support = {
+    driverKind: "grokAgent",
+    displayName: "Grok",
+    images: false,
+    models: STATIC_GROK_MODELS,
+    resolveModels: (env) => mergeLocalInject(readGrokModelCatalog(env), env),
+    // Grok's accepted levels vary by model and the CLI validates lazily — a
+    // rejected level only logs and falls back. Offer the intersection shared
+    // by every model in this driver's picker; notably, grok-4.5 rejects xhigh.
+    effortLevels: ["low", "medium", "high"],
+    defaultCli: "grok",
+    nativeSource: "grok.acp",
+    loginNote: "Grok CLI is not signed in — run `grok login` in a terminal",
+    // No Windows one-liner: the installer is a POSIX shell script, and offering
+    // `curl … | bash` there would be advice that cannot run. Windows falls back
+    // to docsUrl, which is honest rather than broken.
+    install: {
+        command: {
+            darwin: "curl -fsSL https://x.ai/cli/install.sh | bash",
+            linux: "curl -fsSL https://x.ai/cli/install.sh | bash",
+        },
+        docsUrl: "https://x.ai/cli",
+        signInCommand: "grok login",
+    },
+    // Write the [model.slug] block with the instance HOME/GROK_HOME, then pass
+    // the slug on argv. spawnArgs must not call ensureGrokInjectSlug itself —
+    // that helper defaults to process.env and would miss the instance override.
+    resolveTurnModel: (model, env) => (model ? ensureGrokInjectSlug(model, env) : model),
+    // --permission-mode is a global grok flag. -m and --reasoning-effort are
+    // agent flags: Grok 1.0.6 only applies them when they sit AFTER `agent`
+    // and BEFORE `stdio` (`grok agent -m slug stdio`). Putting -m first is
+    // accepted as a TUI option and then ignored, so ACP session/new keeps
+    // [models].default (grok-4.6) and oMLX never sees a request.
+    spawnArgs: (config, turn) => [
+        "--permission-mode",
+        config.fullAuto ? "bypassPermissions" : "default",
+        "agent",
+        ...(turn.model ? ["-m", turn.model] : []),
+        // long form on purpose: `--effort` is documented as an alias, and an
+        // alias is the part a CLI is free to rename
+        ...(turn.effort ? ["--reasoning-effort", turn.effort] : []),
+        "stdio",
+    ],
+    // -m on argv is necessary but not sufficient: session/new still starts on
+    // [models].default. Pin the slug over the wire, same as Hermes/Droid.
+    async configureSession({ request, sessionId, turn }) {
+        if (!turn.model)
+            return;
+        try {
+            await request("session/set_model", { sessionId, modelId: turn.model });
+        }
+        catch (e) {
+            throw new Error(`Grok rejected model "${turn.model}" via session/set_model: ${e.message}. ` +
+                `Check that grok is current (1.0.6+ supports it) and that this slug exists in ~/.grok/config.toml.`);
+        }
+    },
+    // The CLI owns its own grok.com login; a leaked API key silently flips
+    // billing from the subscription to pay-as-you-go.
+    transformEnv: (env) => {
+        delete env.XAI_API_KEY;
+    },
+    // Bind the grok.com subscription login. No API-key fallback by design —
+    // an unauthenticated CLI is a user action, not something to paper over.
+    pickAuthMethod: (methods) => (methods.some((m) => m.id === "cached_token") ? "cached_token" : null),
+    authFailure: "fail",
+    isAuthenticated: () => existsSync(join(homedir(), ".grok", "auth.json")),
+    // `--append-system-prompt`/`--rules` are accepted by the CLI but do NOT
+    // reach the agent-stdio system prompt (verified against 1.0.0), so the
+    // persona is prepended codex-style.
+    buildPromptText: (turn) => (turn.system ? `${turn.system}\n\n${turn.text}` : turn.text),
+};
+export const GrokAgentDriver = createAcpDriver(support);