@ory/antigravity 0.10.0

package/README.md

@@ -0,0 +1,246 @@
+# Ory Agent Plugin: Google Antigravity
+
+[Ory](https://ory.com) bundled into [Google Antigravity](https://antigravity.google): skills and slash commands that scaffold Ory authentication into your codebase, a local Ory stack you can spin up in one command, and (when pointed at an Ory project) authentication, authorization, and audit for every tool Antigravity's agent runs.
+
+You don't need an Ory account or any prior Ory experience to start.
+
+> **Antigravity is the successor to Gemini CLI.** If you used the Ory Gemini CLI extension, this is its counterpart for the `agy` CLI and the Antigravity IDE. Your existing skills and commands carry over.
+
+## New to Ory?
+
+[Ory](https://www.ory.com/docs/) is an open-source identity and access platform — it provides login, registration, sessions, social sign-in, multi-factor auth, and fine-grained permissions, so you don't have to build any of that yourself. Two things make it easy to try with no prior experience:
+
+- **Ory Elements** are prebuilt, themeable UI components for the auth pages (login, registration, recovery, settings). The scaffolding skills wire them into your app for you.
+- **The local Ory stack** is a complete Ory running on your laptop in Docker — no account, no signup, no API key. Everything in the Quickstart below works against it, fully offline.
+
+This plugin does two independent things, and you can use either on its own:
+
+1. **Build auth into your app.** Have Antigravity scaffold Ory login, registration, social sign-in, and permissions into the project you're working on, backed by the local stack. This is the Quickstart below — it needs nothing but Docker.
+2. **Govern the agent itself.** Authenticate the agent's session and authorize every tool it runs against Ory Permissions, with a full audit trail. See [Agent security](#agent-security).
+
+If you're just exploring, do the Quickstart first.
+
+## Prerequisites
+
+- [Google Antigravity](https://antigravity.google) installed (the `agy` CLI and/or the IDE)
+- Node.js **≥ 22**
+- [Docker](https://docs.docker.com/get-docker/) (only needed for the local Ory stack)
+- macOS or Linux. Windows works via WSL2.
+
+## Install
+
+```bash
+npx -y -p @ory/antigravity ory-antigravity install
+```
+
+This materializes the Ory plugin bundle (skills, commands, hooks, and MCP server) and registers it with Antigravity via `agy plugin install`. Then confirm everything landed:
+
+```bash
+npx -y -p @ory/antigravity ory-antigravity status
+```
+
+`status` is the single source of truth — it prints configuration, user and agent identity, per-tool permission coverage, plugin + skill registration, and a tail of recent debug logs. Unconfigured fields show inline as `(unset)`.
+
+<details>
+<summary>Alternative install paths</summary>
+
+```bash
+npx -y -p @ory/antigravity ory-antigravity uninstall
+```
+
+If the `agy` binary isn't on your `PATH`, `npx -y -p @ory/antigravity ory-antigravity-setup` writes the plugin bundle directly into your project's `.agents/` directory (`plugin.json`, `hooks.json`, `mcp_config.json`, `skills/`, `commands/`).
+
+</details>
+
+## Quickstart (≈ 3 minutes)
+
+From any project where you'd like Ory authentication, inside Antigravity:
+
+1. **Start a local Ory instance.** Ask Antigravity *"start the local Ory stack"* or run:
+
+   ```
+   /ory:local-up
+   ```
+
+   A banner prints the seeded test user's email and password. Note them — you'll log in with them in step 3.
+
+2. **Scaffold Ory into your project.** Ask Antigravity *"add Ory auth to this app"* or invoke the `ory-auth-setup` skill.
+
+   Antigravity installs Ory Elements, wires the SDK, generates the login / registration / recovery / verification / settings pages, and sets up session middleware. It targets the local stack from step 1, so no signup or API key is needed.
+
+3. **Sign in.** Start your app, visit the login page Antigravity added, and sign in with the seeded credentials. You now have a real Ory session backed by a real Ory stack — locally, offline, with zero configuration.
+
+4. **Turn on Ory login for the agent session itself.** *(Optional but recommended.)* Out of the box the plugin only governs your *app*. To also attach an Ory identity to the *agent's* session — so every tool call is attributed to you, not a fallback `session:<id>` subject — opt in to the user-login flow:
+
+   ```bash
+   export ORY_USER_LOGIN=true
+   export ORY_OAUTH2_CLIENT_ID=<value printed by `local up`>
+   ```
+
+   User login is off by default. Both exports above are printed in the `local up` banner — copy them straight from there. `ORY_OAUTH2_CLIENT_ID` is required whenever `ORY_USER_LOGIN` is on: it identifies the public OAuth2 client the PKCE browser flow exchanges for a token. With both set, the next session opens an Ory login in your browser; sign in with the same seeded credentials from step 1, and the token is reused on subsequent sessions until it expires. This is what makes `permissions enforce` (see [Agent security](#agent-security)) deny on the right identity later.
+
+That's the full Ory DX path. Stop here if you're just evaluating the plugin. Continue to [Agent security](#agent-security) when you're ready to enforce.
+
+## What's included
+
+### Skills for scaffolding Ory into your application
+
+The plugin bundles a catalog of skills that Antigravity auto-invokes by description. Ask in natural language or invoke a skill directly:
+
+**Start here — add Ory auth to your app:**
+
+- **`ory-auth-setup`** — full project setup. Install the Ory CLI, create an Ory Network project (or use the local one), add Ory Elements, configure the SDK, build the auth pages, wire session middleware.
+- **`ory-login-flow`** — login, registration, recovery, verification, and settings pages with Ory Elements. Next.js App Router and React SPA variants.
+- **`ory-social-login`** — Google, GitHub, Apple, Microsoft, Discord, and other OIDC providers with Jsonnet data mappers.
+- **`ory-local-dev`** — drive the local Ory stack from within Antigravity to prototype and test without a remote project.
+
+**Going further:**
+
+- **`ory-permissions-onboarding`** — bootstrap permissions for built-in tools, switch between observe and enforce mode, troubleshoot denials.
+- **`ory-build-integration`** — pull the runnable subset of an `ory/integrates` template (webhook / config / http-event) into your own app and wire it to your Ory project.
+- **`ory-contribute-integration`** — author a brand-new integration as a contribution to `ory/integrates`.
+- **`ory-e2b-sandbox`** — scaffold an [E2B](https://e2b.dev) sandbox template that boots with this plugin preinstalled and registered.
+- **`ory-build-agent`** — drop `@ory/argus` directly into a custom agent you own (Claude Agent SDK, OpenAI Agents SDK, Mastra, Vercel AI SDK, PydanticAI, LangGraph, Mistral AI, or Salesforce Agentforce).
+- **`ory-temporal-worker`** — scaffold a [Temporal](https://temporal.io) TypeScript worker with every Activity gated by an Ory permission check.
+
+### Ory MCP server
+
+Bundled and registered automatically via `mcp_config.json`. Exposes the Ory CLI and the Ory Network REST API as MCP tools so the agent can manage identities, OAuth2 clients, projects, permissions, and configuration without ever leaving the chat.
+
+### Local Ory stack
+
+```
+/ory:local-up      # start a local Ory instance in Docker
+/ory:local-down    # tear it all down
+/ory:temporal-up   # start a local Temporal dev server (for ory-temporal-worker)
+```
+
+`local-up` runs a complete Ory on your laptop: the Ory APIs (Identities, OAuth2, Permissions) at `http://localhost:4000`, a login UI on `:4455` (not :3000, to avoid Next.js port conflicts), and Jaeger (the trace viewer) on `:16686`. A test user identity is seeded and its credentials are printed for you.
+
+## Pointing at a real Ory project
+
+The Quickstart uses the local stack. If you have a hosted [Ory Network](https://console.ory.sh) project, point the plugin at it with a single configure command. **The plugin requires `--oauth2-client-id` whenever `--project-url` is provided** — register the client first (see [Register the user OAuth2 client](#register-the-user-oauth2-client)), then run:
+
+```bash
+npx -y -p @ory/antigravity ory-antigravity configure \
+  --project-url https://<id>.projects.oryapis.com \
+  --oauth2-client-id <public OAuth2 client id>
+```
+
+- **`--project-url`** points the plugin at your project. The **agent identity** (machine credentials for the agent's outgoing Ory API calls) is created automatically on first run via OAuth2 Dynamic Client Registration ([RFC 7591](https://datatracker.ietf.org/doc/html/rfc7591)) — no manual step required.
+- **`--oauth2-client-id`** is required because the **user** PKCE browser flow (triggered by `ORY_USER_LOGIN=true`) cannot self-register. See [Register the user OAuth2 client](#register-the-user-oauth2-client).
+- **`--api-key ory_pat_...`** is optional — pass it only to override the auto-registered agent identity with a static personal access token.
+
+If you only want audit logging (no auth or permission checks), substitute `--audit-only`:
+
+```bash
+npx -y -p @ory/antigravity ory-antigravity configure --audit-only
+```
+
+The same settings can be supplied via environment variables (`ORY_PROJECT_URL`, `ORY_OAUTH2_CLIENT_ID`, `ORY_AGENT_API_KEY`) — env vars take precedence over the config file when both are set.
+
+Config is saved to `~/.config/ory-agent-plugins/config.json` and shared across every Ory agent plugin on the machine.
+
+Without configuration the plugin still loads cleanly and runs in **pass-through mode**: skills and commands work, but nothing is blocked.
+
+### Register the user OAuth2 client
+
+If you plan to turn on `ORY_USER_LOGIN=true` (recommended), your hosted Ory project needs a **public** OAuth2 client (no client secret) registered ahead of time. The local stack provisions this for you automatically; against a hosted project you register it once yourself.
+
+The client must list **all four** loopback ports as redirect URIs:
+
+- `http://127.0.0.1:47823/callback`
+- `http://127.0.0.1:47824/callback`
+- `http://127.0.0.1:47825/callback`
+- `http://127.0.0.1:47826/callback`
+
+The plugin walks the four ports at runtime so login survives any one of them being occupied. Create the client with the [Ory CLI](https://www.ory.com/docs/guides/cli/installation):
+
+```bash
+ory create oauth2-client --project <project-id> \
+  --name "ory-agent-plugin" \
+  --grant-type authorization_code,refresh_token \
+  --response-type code \
+  --scope openid,offline_access \
+  --token-endpoint-auth-method none \
+  --redirect-uri http://127.0.0.1:47823/callback \
+  --redirect-uri http://127.0.0.1:47824/callback \
+  --redirect-uri http://127.0.0.1:47825/callback \
+  --redirect-uri http://127.0.0.1:47826/callback
+```
+
+…then persist the issued id with `configure --oauth2-client-id`, or set `ORY_OAUTH2_CLIENT_ID` in the environment alongside `ORY_USER_LOGIN`. Headless / CI runs that already hold a session token can skip this by setting `ORY_USER_SESSION_TOKEN` instead.
+
+## Agent security
+
+Once the plugin is pointed at an Ory project (local or hosted), the agent's session and every tool call can be governed by Ory.
+
+- **Authentication.** Two identities. The human at the keyboard (the **user**) authenticates interactively via Ory Identities when user login is enabled (`ORY_USER_LOGIN=true`, off by default). The agent process gets its own OAuth2 identity, self-registered via [Dynamic Client Registration (RFC 7591)](https://datatracker.ietf.org/doc/html/rfc7591) on first run.
+- **Authorization.** Before any tool runs, the plugin's `PreToolUse` hook checks [Ory Permissions](https://www.ory.com/docs/keto) against the user's subject and blocks the call on `deny`.
+- **Audit.** Every decision (allow, deny, fallback) is recorded as a structured trace span: NDJSON file output and/or OTLP/HTTP export to Jaeger, Honeycomb, Grafana, and similar collectors. The user → agent delegation is written to Ory as a relation so *"agent X acting on behalf of user Y"* stays queryable after tokens expire.
+
+The plugin hooks into these Antigravity lifecycle events: `SessionStart` (verify identities), `PreToolUse` (authorize), `PostToolUse` (audit), `Notification`, and `SessionEnd`.
+
+> **Fail-open on a fail-closed harness.** Antigravity blocks a tool unless the `PreToolUse` hook explicitly returns `{ allow_tool: true }` — a crash, timeout, or missing response *blocks* the tool. To preserve Ory's never-get-in-the-way contract, the plugin **always returns "allow" on any internal or network error**, so a transient Ory outage never wedges your tools. Enforcement is therefore only as strong as your permission grants — grant explicit `use` on the tools each user should be able to run.
+
+### Enable enforcement
+
+After install the plugin runs in **observe mode**: every tool call is checked against Ory Permissions, but a deny is recorded as a `permission.observe_deny` audit span and the tool runs anyway. This lets you see what *would* be blocked before turning on hard blocking.
+
+1. **Turn on user login.** It's off by default:
+
+   ```bash
+   export ORY_USER_LOGIN=true
+   export ORY_OAUTH2_CLIENT_ID=<public OAuth2 client id>
+   ```
+
+2. **Bootstrap permissions for the built-in tools.** One idempotent command grants the current user `use` on every tool Antigravity ships with (run_command, view_file, write_to_file, …):
+
+   ```bash
+   npx -y -p @ory/antigravity ory-antigravity permissions bootstrap
+   ```
+
+3. **Check coverage.** `permissions status` probes every tool in the harness's catalog and prints allowed / denied per tool:
+
+   ```bash
+   npx -y -p @ory/antigravity ory-antigravity permissions status
+   ```
+
+4. **Promote to enforce.** Once the observe-mode logs look right:
+
+   ```bash
+   npx -y -p @ory/antigravity ory-antigravity permissions enforce
+   ```
+
+   Denies now block the tool call; Antigravity shows the `deny_reason` and the decision is recorded as a `tool.block` trace span with `blocked: true`. Switch back any time with `permissions observe`.
+
+## CLI reference
+
+```
+npx -y -p @ory/antigravity ory-antigravity install
+npx -y -p @ory/antigravity ory-antigravity uninstall
+npx -y -p @ory/antigravity ory-antigravity configure        [--project-url <url> --oauth2-client-id <id>] [--api-key <key>] [--audit-only]
+npx -y -p @ory/antigravity ory-antigravity agent <status|unregister>
+npx -y -p @ory/antigravity ory-antigravity permissions <status|bootstrap|observe|enforce>
+npx -y -p @ory/antigravity ory-antigravity local <up|down|status|seed|logs|env|configure|reset>
+npx -y -p @ory/antigravity ory-antigravity setup            [--project-dir <path>]   # .agents fallback
+npx -y -p @ory/antigravity ory-antigravity status
+```
+
+## Troubleshooting
+
+- **`/ory:local-up` fails.** Make sure Docker is running and ports `4455` (login UI), `4000`, `4100`, and `16686` are free.
+- **PKCE login loops.** Clear persisted state with `npx -y -p @ory/antigravity ory-antigravity agent unregister` and retry.
+- **`npx` fetches an old version.** Force a fresh fetch: `npx -y -p @ory/antigravity@latest ory-antigravity …`.
+- **A tool was unexpectedly blocked.** Because Antigravity fails closed, confirm the hook is returning JSON — set `ORY_AGENT_DEBUG=true` and `ORY_AGENT_LOG_FILE=/tmp/ory.log` and check for hook errors. Then verify the user has `use` on the tool (`permissions status`).
+
+## Links
+
+- [Ory documentation](https://www.ory.com/docs/)
+- [Ory Network console](https://console.ory.sh)
+- [Ory Elements](https://github.com/ory/elements)
+- [Google Antigravity](https://antigravity.google)
+
+## License
+
+Apache-2.0

package/dist/cli/assets.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Materialize / clean the Ory plugin bundle for Google Antigravity.
+ *
+ * Antigravity plugins are the rebrand of Gemini CLI extensions. A bundle
+ * is a directory containing:
+ *
+ *   plugin.json        required manifest: { name, version, description }
+ *   hooks.json         lifecycle hook registrations (verified schema below)
+ *   mcp_config.json    MCP server registrations
+ *   skills/            Ory skill playbooks (SKILL.md trees)
+ *   commands/<ns>/     TOML slash commands
+ *
+ * Verified against `agy 1.0.13`: `agy plugin validate <dir>` accepts this
+ * layout and reports `hooks`, `mcpServers`, `skills`, and `commands` as
+ * recognized components.
+ *
+ * hooks.json shape (verified): top-level rule id → event name → array of
+ * `{ matcher, hooks: [{ type, command, timeout }] }`.
+ */
+/** Plugin / rule / MCP-server id. */
+export declare const PLUGIN_NAME = "ory";
+/**
+ * Write the full Ory plugin bundle under `root`. Used both for the
+ * bundle handed to `agy plugin install` and for the manual `.agents`
+ * fallback.
+ */
+export declare function installAntigravityOryAssets(root: string): void;
+/** Remove every Ory skill, command, and bundle file written under `root`. */
+export declare function uninstallAntigravityOryAssets(root: string): void;

package/dist/cli/assets.js

@@ -0,0 +1,182 @@
+"use strict";
+/**
+ * Materialize / clean the Ory plugin bundle for Google Antigravity.
+ *
+ * Antigravity plugins are the rebrand of Gemini CLI extensions. A bundle
+ * is a directory containing:
+ *
+ *   plugin.json        required manifest: { name, version, description }
+ *   hooks.json         lifecycle hook registrations (verified schema below)
+ *   mcp_config.json    MCP server registrations
+ *   skills/            Ory skill playbooks (SKILL.md trees)
+ *   commands/<ns>/     TOML slash commands
+ *
+ * Verified against `agy 1.0.13`: `agy plugin validate <dir>` accepts this
+ * layout and reports `hooks`, `mcpServers`, `skills`, and `commands` as
+ * recognized components.
+ *
+ * hooks.json shape (verified): top-level rule id → event name → array of
+ * `{ matcher, hooks: [{ type, command, timeout }] }`.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLUGIN_NAME = void 0;
+exports.installAntigravityOryAssets = installAntigravityOryAssets;
+exports.uninstallAntigravityOryAssets = uninstallAntigravityOryAssets;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const argus_1 = require("@ory/argus");
+const PACKAGE_NAME = "@ory/antigravity";
+const HOOK_BIN_NAME = "ory-antigravity-hook";
+const MCP_PACKAGE_NAME = "@ory/mcp-server";
+const MCP_BIN_NAME = "ory-mcp-server";
+/** Plugin / rule / MCP-server id. */
+exports.PLUGIN_NAME = "ory";
+const RENDER_OPTS = {
+    binName: "ory-antigravity",
+    packageName: PACKAGE_NAME,
+};
+/**
+ * Subdir under `commands/`. The folder name becomes the slash-command
+ * namespace, so `commands/ory/local-up.toml` is exposed as `/ory:local-up`.
+ */
+const CMD_SUBDIR = "ory";
+/** Read the plugin's own version, walking up from dist/cli to the root. */
+function readPackageVersion() {
+    const pkgPath = path.resolve(__dirname, "..", "..", "package.json");
+    const parsed = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    if (!parsed.version)
+        throw new Error(`Could not read version from ${pkgPath}`);
+    return parsed.version;
+}
+/**
+ * Render hooks.json. The hook command is a self-contained
+ * `npx -y -p @ory/antigravity@<version> ory-antigravity-hook` so the
+ * binary need not be on PATH after install. `matcher: ".*"` matches every
+ * tool name on the tool events.
+ */
+function renderHooks(version) {
+    const command = `npx -y -p ${PACKAGE_NAME}@${version} ${HOOK_BIN_NAME}`;
+    const entry = (matcher, timeout) => [
+        { matcher, hooks: [{ type: "command", command, timeout }] },
+    ];
+    return {
+        [exports.PLUGIN_NAME]: {
+            SessionStart: entry(".*", 10000),
+            SessionEnd: entry(".*", 5000),
+            PreToolUse: entry(".*", 5000),
+            PostToolUse: entry(".*", 5000),
+            Notification: entry(".*", 5000),
+        },
+    };
+}
+/** Render plugin.json (required manifest). */
+function renderManifest(version) {
+    return {
+        name: exports.PLUGIN_NAME,
+        version,
+        description: "Ory authentication, authorization, and distributed tracing for Google Antigravity",
+    };
+}
+/**
+ * Render mcp_config.json. Antigravity uses the standard `mcpServers` map;
+ * stdio servers use `command` + `args` (remote servers would use
+ * `serverUrl`). The Ory MCP server is resolved via npx for the same
+ * reason as the hook command.
+ */
+function renderMcpConfig(version) {
+    return {
+        mcpServers: {
+            [exports.PLUGIN_NAME]: {
+                command: "npx",
+                args: ["-y", "-p", `${MCP_PACKAGE_NAME}@${version}`, MCP_BIN_NAME],
+            },
+        },
+    };
+}
+/**
+ * Write the full Ory plugin bundle under `root`. Used both for the
+ * bundle handed to `agy plugin install` and for the manual `.agents`
+ * fallback.
+ */
+function installAntigravityOryAssets(root) {
+    const version = readPackageVersion();
+    fs.mkdirSync(root, { recursive: true });
+    const skillsDir = path.join(root, "skills");
+    fs.rmSync(skillsDir, { recursive: true, force: true });
+    (0, argus_1.writeSkillTree)(skillsDir, (0, argus_1.renderOrySkills)("antigravity", RENDER_OPTS));
+    const cmdDir = path.join(root, "commands", CMD_SUBDIR);
+    fs.rmSync(cmdDir, { recursive: true, force: true });
+    fs.mkdirSync(cmdDir, { recursive: true });
+    for (const cmd of (0, argus_1.renderOryCommands)("antigravity", RENDER_OPTS)) {
+        fs.writeFileSync(path.join(cmdDir, `${cmd.slug}.toml`), (0, argus_1.commandToToml)(cmd));
+    }
+    fs.writeFileSync(path.join(root, "hooks.json"), JSON.stringify(renderHooks(version), null, 2) + "\n");
+    fs.writeFileSync(path.join(root, "mcp_config.json"), JSON.stringify(renderMcpConfig(version), null, 2) + "\n");
+    fs.writeFileSync(path.join(root, "plugin.json"), JSON.stringify(renderManifest(version), null, 2) + "\n");
+}
+function safeRmEmpty(dir) {
+    try {
+        if (fs.existsSync(dir) && fs.readdirSync(dir).length === 0) {
+            fs.rmdirSync(dir);
+        }
+    }
+    catch {
+        /* leave the dir if removal fails */
+    }
+}
+/** Remove every Ory skill, command, and bundle file written under `root`. */
+function uninstallAntigravityOryAssets(root) {
+    const skillsDir = path.join(root, "skills");
+    if (fs.existsSync(skillsDir)) {
+        (0, argus_1.removeSkillDirs)(skillsDir, argus_1.ORY_SKILL_NAMES);
+        safeRmEmpty(skillsDir);
+    }
+    const cmdDir = path.join(root, "commands", CMD_SUBDIR);
+    if (fs.existsSync(cmdDir)) {
+        for (const slug of argus_1.ORY_COMMAND_SLUGS) {
+            const f = path.join(cmdDir, `${slug}.toml`);
+            if (fs.existsSync(f))
+                fs.unlinkSync(f);
+        }
+        safeRmEmpty(cmdDir);
+        safeRmEmpty(path.join(root, "commands"));
+    }
+    for (const f of ["hooks.json", "mcp_config.json", "plugin.json"]) {
+        const p = path.join(root, f);
+        if (fs.existsSync(p))
+            fs.unlinkSync(p);
+    }
+}

package/dist/cli/main.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+/**
+ * Main CLI for @ory/antigravity.
+ *
+ * Usage:
+ *   npx ory-antigravity install              Install the Ory plugin into Antigravity
+ *   npx ory-antigravity uninstall            Remove the plugin
+ *   npx ory-antigravity configure            Set or view Ory credentials
+ *   npx ory-antigravity setup [--project-dir]  Write the bundle into .agents (fallback)
+ *   npx ory-antigravity status               Show plugin status
+ */
+export {};