@ory/gemini-cli 0.1.0

package/README.md

@@ -0,0 +1,100 @@
+# Ory Agent Extension: Gemini CLI
+
+[Ory](https://ory.com) bundled into [Gemini CLI](https://github.com/google-gemini/gemini-cli): skills and TOML 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 Gemini runs.
+
+## Install
+
+Try these in order; the first that works is the simplest path:
+
+**1. Google's public extension registry.** Find **Ory Agent Extension** and install:
+
+```bash
+gemini extensions install ory-agent-extension
+```
+
+**2. The Ory-hosted extension source:**
+
+```bash
+gemini extensions install https://github.com/ory/gemini-cli-extension
+```
+
+**3. The Ory installer.** No prior `npm install` required:
+
+```bash
+npx @ory/gemini-cli install
+npx @ory/gemini-cli uninstall
+```
+
+Every flow installs the same extension: skills, TOML slash commands, hooks, and the Ory MCP server. If the `gemini` binary isn't on your `PATH`, `npx ory-gemini-setup` writes the extension config directly.
+
+## Developer experience
+
+This extension is a productivity layer for Ory itself. You don't need a real Ory project, an account, or any prior Ory experience to start using it.
+
+### Skills for scaffolding Ory into your application
+
+Ask Gemini to add Ory auth to your codebase. The extension bundles four skills that the model auto-invokes by description:
+
+- **`ory-auth-setup`**: full project setup. Install the Ory CLI, create an Ory Network project, 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 (below) from within Gemini to prototype and test against without a remote project.
+
+Skills are versioned with the extension so guidance stays in sync as Ory APIs evolve.
+
+### Ory MCP server
+
+Bundled and registered automatically. It exposes the Ory CLI and the Ory Network REST API as MCP tools so Gemini can manage identities, OAuth2 clients, projects, permission tuples, and configuration without ever leaving the chat. Useful for seeding test data, verifying a scaffolded integration, or running one-off admin tasks.
+
+### Local Ory stack in one command
+
+```
+/ory:local-up      # start a local Ory instance in Docker
+/ory:local-down    # tear it all down
+```
+
+`local up` runs a local Ory instance in Docker, covering everything the extension and your scaffolded application need. It also brings up a login UI on `:3000` and Jaeger on `:16686`, all reachable through `http://localhost:4000`. A test user identity is seeded and the credentials are printed for you. Use it to:
+
+- **Learn Ory hands-on** without signing up for a hosted project.
+- **Prototype** flows (login, social, MFA, recovery, permission tuples) against a real Ory backend in your local dev loop.
+- **Test** an auth integration end-to-end before pushing anything to a real environment.
+- **Develop** your application against the same identity, OAuth2, and permission surfaces you'll ship with.
+
+Point `ORY_PROJECT_URL` at `http://localhost:4000` (or run `npx ory-gemini configure`) and the security features below run against the local stack.
+
+## Configure
+
+```bash
+npx ory-gemini configure --project-url https://<id>.projects.oryapis.com --api-key ory_pat_...
+```
+
+Config is saved to `~/.config/ory-agent-plugins/config.json` and shared across every Ory agent plugin or extension on the machine. Without it the extension still loads cleanly and runs in **pass-through mode**: skills and commands work, but nothing is blocked.
+
+## Agent security (Argus)
+
+Once the extension is pointed at an Ory project (local or hosted), Gemini's session and every tool call are governed by Ory.
+
+- **Authentication.** Two identities. The human at the keyboard (the **user**) authenticates interactively via Ory Identities when `ORY_AUTH_GATE=1`. The Gemini process (the **agent**) gets its own OAuth2 identity, self-registered via Dynamic Client Registration on first run.
+- **Authorization.** Before any tool runs, the extension checks Ory Permissions against the user's subject and blocks the call on `deny`. MCP tool calls additionally get a server-level check.
+- **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-to-agent delegation is written to Ory as a Zanzibar tuple so "agent X acting on behalf of user Y" stays queryable after tokens expire.
+
+The extension is **fail-open** on its own infrastructure failures (network errors, rate limits, missing config), so enforcement is only as strong as your tuples; grant explicit `invoke` relations for the tools each user should be able to run.
+
+## CLI
+
+```
+npx ory-gemini install                             [--link]
+npx ory-gemini uninstall
+npx ory-gemini configure                           [--project-url <url>] [--api-key <key>] [--audit-only]
+npx ory-gemini agent <status|unregister>           Manage the agent's OAuth2 identity
+npx ory-gemini local <up|down|status|seed|logs|env|configure|reset>
+npx ory-gemini status
+```
+
+## Links
+
+- [ory.com](https://ory.com)
+
+## License
+
+Apache-2.0

package/dist/cli/assets.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Materialize / clean the Ory skill catalog and slash commands for the
+ * Gemini CLI plugin. Used both by the primary install path (which seeds
+ * the bundled extension dir before `gemini extensions install`) and by
+ * the manual-setup fallback (which writes into the project's `.gemini/`
+ * tree).
+ */
+/**
+ * Write all Ory skills (4 guide skills) and TOML slash commands (local-up,
+ * local-down) under a Gemini-conventional root containing `skills/` and
+ * `commands/`. For the bundled extension that's the `gemini-extension`
+ * directory; for the manual-setup fallback it's `<projectDir>/.gemini`.
+ */
+export declare function installGeminiOryAssets(root: string): void;
+/** Remove every skill + command this plugin installed under `root`. */
+export declare function uninstallGeminiOryAssets(root: string): void;

package/dist/cli/assets.js

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * Materialize / clean the Ory skill catalog and slash commands for the
+ * Gemini CLI plugin. Used both by the primary install path (which seeds
+ * the bundled extension dir before `gemini extensions install`) and by
+ * the manual-setup fallback (which writes into the project's `.gemini/`
+ * tree).
+ */
+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.installGeminiOryAssets = installGeminiOryAssets;
+exports.uninstallGeminiOryAssets = uninstallGeminiOryAssets;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const argus_1 = require("@ory/argus");
+const RENDER_OPTS = {
+    binName: "ory-gemini",
+    packageName: "@ory/gemini-cli",
+};
+/**
+ * Subdir under `commands/` for our TOML files. The folder name becomes the
+ * slash-command namespace, so files at `commands/ory/local-up.toml` are
+ * exposed as `/ory:local-up`.
+ */
+const CMD_SUBDIR = "ory";
+/**
+ * Write all Ory skills (4 guide skills) and TOML slash commands (local-up,
+ * local-down) under a Gemini-conventional root containing `skills/` and
+ * `commands/`. For the bundled extension that's the `gemini-extension`
+ * directory; for the manual-setup fallback it's `<projectDir>/.gemini`.
+ */
+function installGeminiOryAssets(root) {
+    const skillsDir = path.join(root, "skills");
+    fs.rmSync(skillsDir, { recursive: true, force: true });
+    (0, argus_1.writeSkillTree)(skillsDir, (0, argus_1.renderOrySkills)("gemini-cli", 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)("gemini-cli", RENDER_OPTS)) {
+        fs.writeFileSync(path.join(cmdDir, `${cmd.slug}.toml`), (0, argus_1.commandToToml)(cmd));
+    }
+}
+function safeRmEmpty(dir) {
+    try {
+        if (fs.existsSync(dir) && fs.readdirSync(dir).length === 0) {
+            fs.rmdirSync(dir);
+        }
+    }
+    catch {
+        /* ignore — leave the dir if removal fails. */
+    }
+}
+/** Remove every skill + command this plugin installed under `root`. */
+function uninstallGeminiOryAssets(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"));
+    }
+}

package/dist/cli/main.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+/**
+ * Main CLI for @ory/gemini-cli.
+ *
+ * Usage:
+ *   npx ory-gemini install [--link]         Install as Gemini CLI extension
+ *   npx ory-gemini uninstall                Remove extension
+ *   npx ory-gemini configure                Set or view Ory credentials
+ *   npx ory-gemini setup [--project-dir]    Write hooks to settings.json directly
+ *   npx ory-gemini status                   Show plugin status
+ */
+export {};

package/dist/cli/main.js

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Main CLI for @ory/gemini-cli.
+ *
+ * Usage:
+ *   npx ory-gemini install [--link]         Install as Gemini CLI extension
+ *   npx ory-gemini uninstall                Remove extension
+ *   npx ory-gemini configure                Set or view Ory credentials
+ *   npx ory-gemini setup [--project-dir]    Write hooks to settings.json directly
+ *   npx ory-gemini status                   Show plugin status
+ */
+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 });
+const path = __importStar(require("node:path"));
+const fs = __importStar(require("node:fs"));
+const node_child_process_1 = require("node:child_process");
+const argus_1 = require("@ory/argus");
+const assets_js_1 = require("./assets.js");
+const EXTENSION_DIR = path.resolve(__dirname, "..", "..", "gemini-extension");
+const PACKAGE_ROOT = path.resolve(__dirname, "..", "..");
+function main() {
+    const [command, ...args] = process.argv.slice(2);
+    switch (command) {
+        case "install":
+            install(args);
+            break;
+        case "uninstall":
+            uninstall(args);
+            break;
+        case "configure":
+            (0, argus_1.runConfigureCommand)("ory-gemini", args);
+            break;
+        case "agent":
+            (0, argus_1.runAgentCommand)("ory-gemini", args).then((code) => process.exit(code), (err) => {
+                console.error(err.message ?? err);
+                process.exit(1);
+            });
+            break;
+        case "setup":
+            require("./setup.js");
+            break;
+        case "status":
+            status();
+            break;
+        case "local":
+            (0, argus_1.runLocalCommand)("ory-gemini", args).catch((err) => {
+                console.error(err.message ?? err);
+                process.exit(1);
+            });
+            break;
+        case "help":
+        case "--help":
+        case "-h":
+        case undefined:
+            help();
+            break;
+        default:
+            console.error(`Unknown command: ${command}`);
+            help();
+            process.exit(1);
+    }
+}
+function install(args) {
+    const isLink = args.includes("--link");
+    // Materialize the Ory skill catalog and slash commands into the bundled
+    // extension dir before handing it to `gemini extensions install/link`,
+    // which copies/symlinks the whole tree into ~/.gemini/extensions/ory.
+    console.log("Materializing Ory skills and commands into the extension...");
+    (0, assets_js_1.installGeminiOryAssets)(EXTENSION_DIR);
+    const geminiAvailable = (0, node_child_process_1.spawnSync)("gemini", ["--version"], {
+        stdio: "pipe",
+    }).status === 0;
+    if (geminiAvailable) {
+        if (isLink) {
+            console.log("Linking Ory extension for development...");
+            const result = (0, node_child_process_1.spawnSync)("gemini", ["extensions", "link", EXTENSION_DIR], { stdio: "inherit" });
+            if (result.status === 0) {
+                console.log("");
+                console.log("Ory extension linked for development.");
+                (0, argus_1.printEnvHelp)("ory-gemini");
+            }
+            else {
+                console.error("gemini extensions link failed. Falling back to manual setup...");
+                manualSetup(args);
+            }
+        }
+        else {
+            console.log("Installing Ory extension...");
+            const result = (0, node_child_process_1.spawnSync)("gemini", ["extensions", "install", EXTENSION_DIR], { stdio: "inherit" });
+            if (result.status === 0) {
+                console.log("");
+                console.log("Ory extension installed.");
+                (0, argus_1.printEnvHelp)("ory-gemini");
+            }
+            else {
+                console.error("");
+                console.error("gemini extensions install failed. Falling back to manual setup...");
+                manualSetup(args);
+            }
+        }
+    }
+    else {
+        console.log("Gemini CLI not found on PATH. Using manual setup...");
+        manualSetup(args);
+    }
+}
+function uninstall(args) {
+    const geminiAvailable = (0, node_child_process_1.spawnSync)("gemini", ["--version"], {
+        stdio: "pipe",
+    }).status === 0;
+    if (geminiAvailable) {
+        console.log("Uninstalling Ory extension...");
+        (0, node_child_process_1.spawnSync)("gemini", ["extensions", "uninstall", "ory"], { stdio: "inherit" });
+    }
+    else {
+        const setupArgs = ["--uninstall", ...args];
+        process.argv = ["node", "setup.js", ...setupArgs];
+        require("./setup.js");
+    }
+}
+function manualSetup(args) {
+    process.argv = ["node", "setup.js", ...args];
+    require("./setup.js");
+}
+function status() {
+    console.log("Ory Agent Plugin Status (Gemini CLI)");
+    console.log("====================================");
+    console.log("");
+    (0, argus_1.printOryConfig)();
+    (0, argus_1.printEnvironment)();
+    // Extension-specific status
+    console.log("");
+    console.log("Extension:");
+    console.log(`  Directory: ${EXTENSION_DIR}`);
+    console.log(`  Manifest:  ${fs.existsSync(path.join(EXTENSION_DIR, "gemini-extension.json")) ? "found" : "MISSING"}`);
+    console.log(`  Hook script: ${fs.existsSync(path.join(PACKAGE_ROOT, "dist", "hook.js")) ? "built" : "NOT BUILT (run pnpm build)"}`);
+    const home = process.env.HOME ?? process.env.USERPROFILE ?? "~";
+    const extensionInstalled = fs.existsSync(path.join(home, ".gemini", "extensions", "ory"));
+    console.log(`  Installed:   ${extensionInstalled ? "yes (~/.gemini/extensions/ory)" : "no"}`);
+    (0, argus_1.printLogTail)();
+}
+function help() {
+    console.log(`
+ory-gemini — Ory plugin for Gemini CLI
+
+Usage:
+  npx ory-gemini <command> [options]
+
+Commands:
+  install [--link]       Install the Ory extension into Gemini CLI
+  uninstall              Remove the Ory extension from Gemini CLI
+  configure              Set or view Ory project URL and API key
+  setup [--project-dir]  Write hooks directly to settings.json (fallback)
+  status                 Show plugin status and configuration
+  local <cmd>            Manage local Ory dev environment (up, down, status, seed, ...)
+
+After installing, the extension hooks into these Gemini CLI lifecycle events:
+  SessionStart           Verify agent session via Ory Identities
+  BeforeTool             Check tool permissions via Ory Permissions
+  AfterTool              Audit log tool executions
+
+Examples:
+  npx ory-gemini install            # Install extension
+  npx ory-gemini install --link     # Link for development
+  npx ory-gemini status             # Check configuration
+  npx ory-gemini uninstall          # Remove extension
+`);
+}
+main();

package/dist/cli/setup.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+/**
+ * Setup CLI for the Ory Gemini CLI plugin.
+ *
+ * Usage:
+ *   npx ory-gemini-setup                    # Auto-detect and configure
+ *   npx ory-gemini-setup --project-dir /path/to/repo
+ *   npx ory-gemini-setup --print            # Print config to stdout without writing
+ *   npx ory-gemini-setup --uninstall        # Remove Ory hooks from settings
+ */
+export {};

package/dist/cli/setup.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Setup CLI for the Ory Gemini CLI plugin.
+ *
+ * Usage:
+ *   npx ory-gemini-setup                    # Auto-detect and configure
+ *   npx ory-gemini-setup --project-dir /path/to/repo
+ *   npx ory-gemini-setup --print            # Print config to stdout without writing
+ *   npx ory-gemini-setup --uninstall        # Remove Ory hooks from settings
+ */
+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 });
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const argus_1 = require("@ory/argus");
+const assets_js_1 = require("./assets.js");
+const BIN_NAME = "ory-gemini-hook";
+const PACKAGE_NAME = "@ory/gemini-cli";
+function getSettingsPath(args) {
+    return path.join(args.projectDir, ".gemini", "settings.json");
+}
+function generateHooksConfig() {
+    const cmd = (0, argus_1.resolveHookCommand)(PACKAGE_NAME, BIN_NAME);
+    return {
+        SessionStart: (0, argus_1.matcherHookEntry)(cmd),
+        SessionEnd: (0, argus_1.matcherHookEntry)(cmd),
+        BeforeTool: (0, argus_1.matcherHookEntry)(cmd),
+        AfterTool: (0, argus_1.matcherHookEntry)(cmd),
+        BeforeToolSelection: (0, argus_1.matcherHookEntry)(cmd),
+        Notification: (0, argus_1.matcherHookEntry)(cmd),
+        PreCompress: (0, argus_1.matcherHookEntry)(cmd),
+    };
+}
+function main() {
+    if (process.argv.includes("--help") || process.argv.includes("-h")) {
+        (0, argus_1.printSetupHelp)("ory-gemini-setup", "Gemini CLI");
+        process.exit(0);
+    }
+    const args = (0, argus_1.parseSetupArgs)();
+    const hooksConfig = generateHooksConfig();
+    if (args.print) {
+        console.log(JSON.stringify({ hooks: hooksConfig }, null, 2));
+        return;
+    }
+    const settingsPath = getSettingsPath(args);
+    const existing = (0, argus_1.readJsonFile)(settingsPath);
+    const geminiDir = path.join(args.projectDir, ".gemini");
+    if (args.uninstall) {
+        if (!fs.existsSync(settingsPath)) {
+            console.log("No settings file found. Nothing to uninstall.");
+            return;
+        }
+        let updated = (0, argus_1.removeMatcherHooks)(existing, BIN_NAME);
+        updated = (0, argus_1.removeMcpServer)(updated);
+        (0, argus_1.writeJsonFile)(settingsPath, updated);
+        (0, assets_js_1.uninstallGeminiOryAssets)(geminiDir);
+        console.log(`Removed Ory hooks and MCP server from ${settingsPath}`);
+        console.log(`Removed Ory skills and commands from ${geminiDir}`);
+        return;
+    }
+    let merged = (0, argus_1.mergeMatcherHooks)(existing, hooksConfig, BIN_NAME);
+    merged = (0, argus_1.mergeMcpServer)(merged);
+    (0, argus_1.writeJsonFile)(settingsPath, merged);
+    (0, assets_js_1.installGeminiOryAssets)(geminiDir);
+    console.log(`Ory hooks and MCP server installed to ${settingsPath}`);
+    console.log(`Ory skills and commands installed to ${geminiDir}`);
+    (0, argus_1.printNextSteps)("Gemini CLI", "npx ory-gemini-setup --uninstall");
+}
+main();

package/dist/handlers.d.ts

@@ -0,0 +1,12 @@
+import { OryAgentClient, ensureUserAuthenticated, ensureAgentIdentity } from "@ory/argus";
+import type { GeminiHookInput, GeminiHookOutput } from "./types.js";
+export interface HandleHookEventDeps {
+    /** Test injection point for the user auth gate. */
+    authGate?: typeof ensureUserAuthenticated;
+    /** Test injection point for the agent identity gate. */
+    agentGate?: typeof ensureAgentIdentity;
+}
+/**
+ * Route a Gemini CLI hook event to the appropriate Ory integration.
+ */
+export declare function handleHookEvent(input: GeminiHookInput, client: OryAgentClient, deps?: HandleHookEventDeps): Promise<GeminiHookOutput>;