@cavi-ai/antigravity 0.2.0 → 0.2.3

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 0.2.3
+
+- Use OpenClaw's provider-owned guided discovery for Control UI reconnect, the
+  same local-CLI path as Ollama and LM Studio. Models → Providers shows
+  **Reconnect** and persists the non-secret connection without an OpenClaw
+  credential. This replaces the 0.2.2 credential-only Connect routing, which
+  is not a host contract for profileless CLI sessions.
+
+## 0.2.2
+
+- Route Control UI login through the credential-only provider connection flow.
+  This avoids inference-gated setup, which cannot safely use `agy` because the
+  CLI does not expose a hard tool-free mode.
+
+## 0.2.1
+
+- Register `before_prompt_build` with `api.on` so the plugin loads on current
+  OpenClaw hosts. `0.2.0` called `registerHook` without a name and aborted
+  registration with `hook registration missing name`.
+
 ## 0.2.0
 
 - Add provider-owned guided setup that validates the external `agy` session

package/README.md

@@ -37,7 +37,10 @@ Restart the OpenClaw Gateway after installation.
 
 ## Connect
 
-In OpenClaw, select **Antigravity CLI** and choose **Reconnect**. The plugin validates the existing `agy` session and makes its models available without creating a separate credential.
+In the Control UI, open **Models → Providers** and choose **Reconnect** on the
+Antigravity CLI card. The plugin validates the existing `agy` session and
+refreshes the provider connection without creating a credential or changing the
+default model.
 
 ## Use
 
@@ -116,8 +119,17 @@ openclaw config set plugins.entries.antigravity.config.command /absolute/path/to
 ```bash
 npm test          # plugin behaviour
 npm run docs:test # documentation build/verify/release tooling
+npm run check:host-integration # live agy + isolated installed-host Reconnect check
 ```
 
+The host-integration check requires a signed-in `agy` session and a compatible
+installed `openclaw` command. It runs `agy models`, starts the working-tree
+plugin in a temporary loopback-only OpenClaw state, verifies that the host
+projects **Reconnect** for Antigravity, and verifies that credential-only
+**Connect** is absent. The temporary gateway and state are removed afterward;
+the installed gateway, OpenClaw config, credentials, and default model are not
+changed. Set `AGY_BIN` or `OPENCLAW_BIN` to use a non-default executable.
+
 Releasing docs is automated: publish a GitHub Release `vX.Y.Z` (matching
 `package.json`) and the `Publish release documentation` workflow builds the
 versioned artifact, attaches it to the release, and dispatches cavi-home to

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "antigravity",
   "name": "Antigravity CLI",
-  "version": "0.2.0",
+  "version": "0.2.3",
   "description": "Runs Google's Antigravity CLI (agy) as a subscription-backed model provider.",
   "enabledByDefault": false,
   "activation": {
@@ -31,8 +31,7 @@
       "choiceHint": "Use an existing Antigravity CLI (agy) login on this host. Run `agy models` to confirm.",
       "groupId": "antigravity",
       "groupLabel": "Antigravity",
-      "groupHint": "Subscription-backed models via agy",
-      "onboardingFeatured": true
+      "groupHint": "Subscription-backed models via agy"
     }
   ],
   "uiHints": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cavi-ai/antigravity",
-  "version": "0.2.0",
+  "version": "0.2.3",
   "description": "Runs Google's Antigravity CLI (agy) as a subscription-backed OpenClaw model provider.",
   "keywords": [
     "openclaw",
@@ -29,6 +29,7 @@
   },
   "files": [
     "src",
+    "scripts/check-host-integration.mjs",
     "setup-api.js",
     "doctor-contract-api.js",
     "openclaw.plugin.json",
@@ -65,6 +66,7 @@
   },
   "scripts": {
     "test": "node --test test/*.test.mjs",
+    "check:host-integration": "node scripts/check-host-integration.mjs",
     "docs:test": "node --test scripts/docs/*.test.mjs",
     "docs:build": "node scripts/docs/build.mjs",
     "docs:verify": "node scripts/docs/verify.mjs",

package/scripts/check-host-integration.mjs

@@ -0,0 +1,271 @@
+#!/usr/bin/env node
+
+import { execFileSync, spawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { createServer } from "node:net";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseAntigravityModelIds } from "../src/provider.js";
+
+const PROVIDER_ID = "antigravity-cli";
+const CHOICE_ID = "antigravity-cli";
+const ACTION_LABEL = "Reconnect";
+const MIN_HOST_VERSION = [2026, 7, 0];
+const COMMAND_TIMEOUT_MS = 30_000;
+const STARTUP_TIMEOUT_MS = 20_000;
+
+function fail(message) {
+  throw new Error(`Host integration check failed: ${message}`);
+}
+
+export function assertAgySession(output) {
+  const modelIds = parseAntigravityModelIds(output);
+  if (modelIds.length === 0) {
+    fail("no models were returned by a live `agy` session; run `agy models` and sign in if needed");
+  }
+  return modelIds;
+}
+
+export function assertReconnectProjection(status) {
+  const capability = status?.providerCapabilities?.find(
+    (candidate) => candidate?.provider === PROVIDER_ID,
+  );
+  if (!capability) {
+    fail(`the OpenClaw host did not publish capabilities for ${PROVIDER_ID}`);
+  }
+  if (capability.loginOptions?.length) {
+    fail("credential-only Connect is exposed for Antigravity");
+  }
+  const reconnect = capability.setupActions?.find(
+    (action) => action?.choiceId === CHOICE_ID && action?.actionLabel === ACTION_LABEL,
+  );
+  if (!reconnect) {
+    fail('the Antigravity guided-discovery action is not labeled "Reconnect"');
+  }
+  return { choiceId: reconnect.choiceId, actionLabel: reconnect.actionLabel };
+}
+
+function parseHostVersion(output) {
+  const match = String(output).match(/OpenClaw\s+(\d+)\.(\d+)\.(\d+)/u);
+  if (!match) {
+    fail(`could not parse the installed OpenClaw version from ${JSON.stringify(String(output).trim())}`);
+  }
+  return match.slice(1, 4).map(Number);
+}
+
+function compareVersions(left, right) {
+  for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
+    const difference = (left[index] ?? 0) - (right[index] ?? 0);
+    if (difference !== 0) return Math.sign(difference);
+  }
+  return 0;
+}
+
+export function commandOutput(command, args, options = {}) {
+  const timeout = options.timeout ?? COMMAND_TIMEOUT_MS;
+  try {
+    return execFileSync(command, args, {
+      encoding: "utf8",
+      maxBuffer: 16 * 1024 * 1024,
+      stdio: ["ignore", "pipe", "pipe"],
+      ...options,
+      timeout,
+    });
+  } catch (error) {
+    if (error?.code === "ETIMEDOUT") {
+      fail(`${command} timed out after ${timeout}ms`);
+    }
+    throw error;
+  }
+}
+
+function parseJsonOutput(command, args, options) {
+  const output = commandOutput(command, args, options);
+  try {
+    return JSON.parse(output);
+  } catch {
+    fail(`${command} returned non-JSON output`);
+  }
+}
+
+export function buildGatewayCallArgs(method, gatewayUrl, token, timeout = 10_000) {
+  return [
+    "gateway",
+    "call",
+    method,
+    "--url",
+    gatewayUrl,
+    "--token",
+    token,
+    "--json",
+    "--timeout",
+    String(timeout),
+  ];
+}
+
+async function reserveLoopbackPort() {
+  const server = createServer();
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", resolve);
+  });
+  const address = server.address();
+  const port = typeof address === "object" && address ? address.port : null;
+  await new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())));
+  if (!port) fail("could not reserve a loopback port for the isolated host");
+  return port;
+}
+
+async function delay(milliseconds) {
+  await new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+
+async function waitForGateway(openclaw, gatewayUrl, token, env, child, diagnostics) {
+  const deadline = Date.now() + STARTUP_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    if (child.exitCode !== null) {
+      fail(`the isolated OpenClaw gateway exited early${diagnostics()}`);
+    }
+    try {
+      parseJsonOutput(openclaw, buildGatewayCallArgs("health", gatewayUrl, token, 1_000), {
+        env,
+        timeout: 2_000,
+      });
+      return;
+    } catch {
+      await delay(250);
+    }
+  }
+  fail(`the isolated OpenClaw gateway did not become ready within ${STARTUP_TIMEOUT_MS}ms${diagnostics()}`);
+}
+
+async function stopGateway(child) {
+  if (child.exitCode !== null) return;
+  child.kill("SIGTERM");
+  await Promise.race([
+    new Promise((resolve) => child.once("exit", resolve)),
+    delay(3_000).then(() => child.kill("SIGKILL")),
+  ]);
+}
+
+function boundedDiagnostics(chunks) {
+  const text = chunks.join("").trim();
+  return text ? `\nGateway diagnostics:\n${text.slice(-4_000)}` : "";
+}
+
+export async function withTemporaryRoot(run) {
+  const tempRoot = await mkdtemp(join(tmpdir(), "antigravity-host-check-"));
+  try {
+    return await run(tempRoot);
+  } finally {
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+}
+
+export async function runHostIntegrationCheck({
+  openclaw = process.env.OPENCLAW_BIN?.trim() || "openclaw",
+  agy = process.env.AGY_BIN?.trim() || "agy",
+} = {}) {
+  const pluginRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+  const packageJson = JSON.parse(await readFile(join(pluginRoot, "package.json"), "utf8"));
+  const hostVersion = parseHostVersion(commandOutput(openclaw, ["--version"]));
+  if (compareVersions(hostVersion, MIN_HOST_VERSION) < 0) {
+    fail(`OpenClaw ${hostVersion.join(".")} is older than the required ${MIN_HOST_VERSION.join(".")}`);
+  }
+
+  const modelIds = assertAgySession(commandOutput(agy, ["models"]));
+  return await withTemporaryRoot(async (tempRoot) => {
+    const stateDir = join(tempRoot, "state");
+    const configPath = join(tempRoot, "openclaw.json");
+    const port = await reserveLoopbackPort();
+    const gatewayUrl = `ws://127.0.0.1:${port}`;
+    const gatewayToken = randomBytes(24).toString("hex");
+    const env = {
+      ...process.env,
+      OPENCLAW_CONFIG_PATH: configPath,
+      OPENCLAW_CONFIG_READONLY: "1",
+      OPENCLAW_STATE_DIR: stateDir,
+    };
+    const gatewayOutput = [];
+    let gateway;
+
+    try {
+      await mkdir(stateDir, { recursive: true });
+      await writeFile(
+        configPath,
+        `${JSON.stringify(
+          {
+            gateway: { mode: "local", bind: "loopback", auth: { mode: "token" } },
+            plugins: {
+              allow: ["antigravity"],
+              load: { paths: [pluginRoot] },
+              entries: { antigravity: { enabled: true, config: { command: agy } } },
+            },
+          },
+          null,
+          2,
+        )}\n`,
+        { mode: 0o600 },
+      );
+
+      gateway = spawn(
+        openclaw,
+        [
+          "gateway",
+          "run",
+          "--port",
+          String(port),
+          "--bind",
+          "loopback",
+          "--auth",
+          "token",
+          "--token",
+          gatewayToken,
+          "--allow-unconfigured",
+        ],
+        { env, stdio: ["ignore", "pipe", "pipe"] },
+      );
+      gateway.stdout.on("data", (chunk) => gatewayOutput.push(String(chunk)));
+      gateway.stderr.on("data", (chunk) => gatewayOutput.push(String(chunk)));
+      const diagnostics = () => boundedDiagnostics(gatewayOutput);
+
+      await waitForGateway(openclaw, gatewayUrl, gatewayToken, env, gateway, diagnostics);
+      const status = parseJsonOutput(
+        openclaw,
+        buildGatewayCallArgs("models.authStatus", gatewayUrl, gatewayToken),
+        { env, timeout: 15_000 },
+      );
+      const action = assertReconnectProjection(status);
+      return {
+        pluginVersion: packageJson.version,
+        hostVersion: hostVersion.join("."),
+        agyModelCount: modelIds.length,
+        action,
+      };
+    } finally {
+      if (gateway) await stopGateway(gateway);
+    }
+  });
+}
+
+const isMain = process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1];
+if (isMain) {
+  runHostIntegrationCheck()
+    .then((result) => {
+      process.stdout.write(
+        [
+          `PASS @cavi-ai/antigravity ${result.pluginVersion}`,
+          `OpenClaw ${result.hostVersion}`,
+          `live agy models: ${result.agyModelCount}`,
+          `host action: ${result.action.actionLabel}`,
+          "credential-only Connect: absent",
+        ].join("\n") + "\n",
+      );
+    })
+    .catch((error) => {
+      process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+      process.exitCode = 1;
+    });
+}

package/src/index.js

@@ -7,7 +7,7 @@ export const PLUGIN_ID = "antigravity";
 export const plugin = {
   id: PLUGIN_ID,
   name: "Antigravity CLI",
-  version: "0.2.0",
+  version: "0.2.3",
   description: "Runs Google's Antigravity CLI (agy) as a subscription-backed model provider.",
   register: registerAntigravity,
 };

package/src/provider.js

@@ -1,6 +1,6 @@
 // Provider registration for Antigravity (`agy`).
 //
-// agy owns the user's Antigravity OAuth session. The custom auth method below
+// agy owns the user's Antigravity OAuth session. Guided discovery/reconnect
 // validates that CLI-owned session and records the provider's non-secret
 // connection (models, endpoint) in config; OpenClaw stores no key for this provider.
 import { execFile } from "node:child_process";

package/src/register.js

@@ -8,17 +8,18 @@ const ANTIGRAVITY_OPENCLAW_CONTEXT = [
   "Do not change global OpenClaw or mcporter configuration unless the user explicitly asks.",
 ].join(" ");
 
+function injectOpenClawGuidance(_event, context) {
+  return context?.modelProviderId === "antigravity-cli"
+    ? { prependContext: ANTIGRAVITY_OPENCLAW_CONTEXT }
+    : undefined;
+}
+
 /** Shared by runtime entry and package-root setup-api. */
 export function registerAntigravity(api) {
   const config = api?.pluginConfig ?? {};
   api.registerProvider(buildAntigravityProvider(config));
   api.registerCliBackend(buildAntigravityCliBackend(config));
-  api.registerHook?.(
-    "before_prompt_build",
-    (_event, context) =>
-      context?.modelProviderId === "antigravity-cli"
-        ? { prependContext: ANTIGRAVITY_OPENCLAW_CONTEXT }
-        : undefined,
-    { registrationId: "antigravity-openclaw-cli-guidance" },
-  );
+  // Typed lifecycle hooks only fire through api.on. registerHook("before_prompt_build")
+  // is ignored, and without opts.name it throws and aborts the whole plugin.
+  api.on?.("before_prompt_build", injectOpenClawGuidance);
 }