@ory/antigravity 0.10.0

package/dist/hook.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Google Antigravity hook entry point.
+ *
+ * Antigravity invokes this script as a subprocess for each hook event.
+ *   Input:  JSON on stdin.
+ *   Output: JSON on stdout.
+ *
+ * FAIL-CLOSED CONTRACT (the reason this differs from every other plugin):
+ * on a `PreToolUse` event, Antigravity blocks the tool unless the hook
+ * returns `{"allow_tool": true}`. A crash, a timeout, malformed output, or
+ * a non-zero exit are all treated as "block". To preserve this repo's
+ * fail-open guarantee, EVERY error path here emits `{"allow_tool": true}`
+ * and exits 0 — a transient Ory/network failure must never wedge the
+ * user's tools. Emitting `allow_tool` on non-tool events is harmless
+ * (the harness ignores it), so the safe default works for all events.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const argus_1 = require("@ory/argus");
+const handlers_js_1 = require("./handlers.js");
+/** The fail-open response: explicitly allow, so a crash never blocks. */
+const FAIL_OPEN = { allow_tool: true };
+/**
+ * Read all of stdin as a string. Uses event listeners (not `for await`)
+ * with an idle timer so we don't hang if the parent never sends EOF.
+ */
+function readStdin() {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let resolved = false;
+        let idleTimer;
+        function done() {
+            if (!resolved) {
+                resolved = true;
+                resolve(Buffer.concat(chunks).toString("utf-8"));
+            }
+        }
+        process.stdin.on("data", (chunk) => {
+            chunks.push(chunk);
+            clearTimeout(idleTimer);
+            idleTimer = setTimeout(done, 100);
+        });
+        process.stdin.on("end", done);
+        process.stdin.on("error", (err) => {
+            if (!resolved) {
+                resolved = true;
+                reject(err);
+            }
+        });
+    });
+}
+async function main() {
+    const client = argus_1.OryAgentClient.fromEnv("antigravity");
+    const raw = await readStdin();
+    let input;
+    try {
+        input = JSON.parse(raw);
+    }
+    catch {
+        client.logger.error("hook.stdin.parse_failed", { raw: raw.slice(0, 200) });
+        // Can't tell the event; allow to avoid wedging a PreToolUse call.
+        process.stdout.write(JSON.stringify(FAIL_OPEN));
+        await client.tracer.shutdown();
+        process.exit(0);
+    }
+    let output;
+    try {
+        output = await (0, handlers_js_1.handleHookEvent)(input, client);
+    }
+    catch (err) {
+        client.logger.error("hook.handler.error", {
+            event: input.hook_event_name,
+            message: err instanceof Error ? err.message : String(err),
+        });
+        output = FAIL_OPEN;
+    }
+    process.stdout.write(JSON.stringify(output));
+    await client.tracer.shutdown();
+    process.exit(0);
+}
+main().catch((err) => {
+    // Last-resort guard: allow rather than block, then exit cleanly.
+    process.stderr.write(`[ory-agent] fatal: ${err}\n`);
+    process.stdout.write(JSON.stringify(FAIL_OPEN));
+    process.exit(0);
+});

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { handleHookEvent } from "./handlers.js";
+export type { HandleHookEventDeps } from "./handlers.js";
+export type { AntigravityHookInput, AntigravityHookOutput } from "./types.js";
+export { installAntigravityOryAssets, uninstallAntigravityOryAssets, } from "./cli/assets.js";

package/dist/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uninstallAntigravityOryAssets = exports.installAntigravityOryAssets = exports.handleHookEvent = void 0;
+var handlers_js_1 = require("./handlers.js");
+Object.defineProperty(exports, "handleHookEvent", { enumerable: true, get: function () { return handlers_js_1.handleHookEvent; } });
+var assets_js_1 = require("./cli/assets.js");
+Object.defineProperty(exports, "installAntigravityOryAssets", { enumerable: true, get: function () { return assets_js_1.installAntigravityOryAssets; } });
+Object.defineProperty(exports, "uninstallAntigravityOryAssets", { enumerable: true, get: function () { return assets_js_1.uninstallAntigravityOryAssets; } });

package/dist/types.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Google Antigravity (`agy` CLI / IDE) hook contract.
+ *
+ * Verified against `agy 1.0.13`: hooks run as subprocesses, receive a
+ * JSON payload on stdin, and emit a JSON response on stdout. The payload
+ * uses Claude-Code-style snake_case field names (`tool_name`,
+ * `tool_input`, `session_id`, `transcript_path`, `hook_event_name`).
+ *
+ * IMPORTANT — Antigravity hooks FAIL CLOSED. On a `PreToolUse` event, a
+ * hook that crashes, times out, or omits `allow_tool` BLOCKS the tool
+ * call. This is the inverse of every other harness in this repo, so the
+ * hook entry point must always emit `{ "allow_tool": true }` (and exit 0)
+ * on any allow/error path. See `hook.ts`.
+ */
+/** Hook event names emitted by Antigravity. */
+export type AntigravityHookEvent = "SessionStart" | "SessionEnd" | "PreToolUse" | "PostToolUse" | "PreInvocation" | "PostInvocation" | "Stop" | "Notification" | string;
+/**
+ * Hook event payload delivered on stdin. Field availability depends on
+ * `hook_event_name`; everything past the first two is optional.
+ */
+export interface AntigravityHookInput {
+    hook_event_name: AntigravityHookEvent;
+    session_id: string;
+    /** Path to the conversation transcript for this session. */
+    transcript_path?: string;
+    /** Workspace roots for the session. */
+    workspace_paths?: string[];
+    /** Current working directory, when provided. */
+    cwd?: string;
+    /** Tool the agent is about to run (or just ran). */
+    tool_name?: string;
+    /** Arguments passed to the tool. */
+    tool_input?: Record<string, unknown>;
+    /** Tool result, on PostToolUse. */
+    tool_response?: Record<string, unknown>;
+    /** Tool error payload, when a tool failed. */
+    tool_error?: unknown;
+    model?: string;
+    /** SessionStart source: startup | resume | ... */
+    source?: string;
+    /** Termination reason. */
+    reason?: string;
+    /** Free-form notification / permission-prompt message. */
+    message?: string;
+    [key: string]: unknown;
+}
+/**
+ * Hook response written to stdout.
+ *
+ * On `PreToolUse`, `allow_tool` is authoritative:
+ *   - `allow_tool: true`  → the tool runs.
+ *   - `allow_tool: false` → the tool is blocked; `deny_reason` is shown.
+ *   - omitted / invalid   → Antigravity FAILS CLOSED and blocks the tool.
+ *
+ * For non-tool events, an empty object (or no output) is fine.
+ */
+export interface AntigravityHookOutput {
+    /** PreToolUse gate decision. Always set it explicitly on PreToolUse. */
+    allow_tool?: boolean;
+    /** Human-readable reason shown when `allow_tool` is false. */
+    deny_reason?: string;
+    /** Optional audit/log message surfaced by the harness. */
+    system_message?: string;
+}

package/dist/types.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * Google Antigravity (`agy` CLI / IDE) hook contract.
+ *
+ * Verified against `agy 1.0.13`: hooks run as subprocesses, receive a
+ * JSON payload on stdin, and emit a JSON response on stdout. The payload
+ * uses Claude-Code-style snake_case field names (`tool_name`,
+ * `tool_input`, `session_id`, `transcript_path`, `hook_event_name`).
+ *
+ * IMPORTANT — Antigravity hooks FAIL CLOSED. On a `PreToolUse` event, a
+ * hook that crashes, times out, or omits `allow_tool` BLOCKS the tool
+ * call. This is the inverse of every other harness in this repo, so the
+ * hook entry point must always emit `{ "allow_tool": true }` (and exit 0)
+ * on any allow/error path. See `hook.ts`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,92 @@
+{
+  "name": "@ory/antigravity",
+  "version": "0.10.0",
+  "description": "Ory plugin for Google Antigravity: scaffolding skills, a local Ory instance, and authentication, authorization, and audit for every tool call",
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/ory/ory-agent-plugins/tree/main/packages/antigravity",
+  "bugs": {
+    "url": "https://github.com/ory/ory-agent-plugins/issues"
+  },
+  "keywords": [
+    "ory",
+    "antigravity",
+    "google-antigravity",
+    "agy",
+    "gemini",
+    "hooks",
+    "plugin",
+    "identity",
+    "identity-management",
+    "iam",
+    "authentication",
+    "authorization",
+    "access-control",
+    "permissions",
+    "rbac",
+    "zanzibar",
+    "oauth",
+    "oauth2",
+    "openid-connect",
+    "oidc",
+    "session",
+    "mfa",
+    "sso",
+    "audit",
+    "audit-log",
+    "compliance",
+    "agent",
+    "ai-agent",
+    "agent-security",
+    "guardrails",
+    "llm",
+    "mcp",
+    "mcp-server",
+    "tracing",
+    "distributed-tracing",
+    "observability",
+    "kratos",
+    "keto",
+    "hydra"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/",
+    "provenance": true
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "ory-antigravity": "dist/cli/main.js",
+    "ory-antigravity-hook": "dist/hook.js",
+    "ory-antigravity-setup": "dist/cli/setup.js"
+  },
+  "files": [
+    "dist",
+    "!dist/dev",
+    "!dist/**/*.tsbuildinfo"
+  ],
+  "dependencies": {
+    "@ory/argus": "0.10.0"
+  },
+  "devDependencies": {
+    "typescript": "^6.0.2",
+    "vitest": "4.1.4"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist *.tsbuildinfo",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "dev": "node dist/dev/launcher.js"
+  }
+}