@ory/github-copilot 0.0.0-stage → 1.5.0

package/README.md

@@ -1,3 +1,31 @@
-# Temporary Holding Version
+# Ory Agent Security for GitHub Copilot CLI
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Install the Agent Plugins 1.0 bundle with GitHub Copilot CLI 1.0 or later:
+
+```sh
+npx -y -p @ory/github-copilot ory-copilot install
+```
+
+The plugin contributes the shared Ory skills and MCP server and registers native
+camelCase Copilot hooks. `preToolUse` is the enforcement boundary: enforce-mode
+policy denial returns Copilot's native deny decision, while observe mode and Ory
+infrastructure failures return no decision and exit successfully, preserving
+Copilot's normal permission flow.
+
+```sh
+npx -y -p @ory/github-copilot ory-copilot configure \
+  --project-url https://<slug>.projects.oryapis.com \
+  --agent-security-url https://agents.console.ory.com
+npx -y -p @ory/github-copilot ory-copilot status
+npx -y -p @ory/github-copilot ory-copilot uninstall
+```
+
+Copilot command-hook crashes and non-zero exits are fail-closed. The Ory hook
+therefore catches adapter failures and exits 0 with an empty decision. An Ory
+allow result does the same; only an explicit enforce-mode denial overrides
+Copilot's permission handling.
+Copilot hook timeouts are controlled by Copilot itself and are fail-open; Copilot
+surfaces a timeout warning, and the timed-out process may not persist an Ory event.
+
+For noninteractive Copilot cloud agent jobs, use the separate repository recipe
+in [`examples/github-copilot-cloud-agent`](../../examples/github-copilot-cloud-agent).

package/dist/cli/assets.d.ts

@@ -0,0 +1,3 @@
+import { type PreparedRuntime } from "@ory/argus";
+export declare function wireGitHubCopilotRuntime(args: readonly string[]): PreparedRuntime;
+export declare function installPluginAssets(root: string, runtime: PreparedRuntime): void;

package/dist/cli/assets.js

@@ -0,0 +1,120 @@
+"use strict";
+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.wireGitHubCopilotRuntime = wireGitHubCopilotRuntime;
+exports.installPluginAssets = installPluginAssets;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const argus_1 = require("@ory/argus");
+const PACKAGE_NAME = "@ory/github-copilot";
+const HARNESS = "github-copilot";
+const PACKAGE_ROOT = path.resolve(__dirname, "..", "..");
+const SCHEMA_ROOT = "https://agent-plugins.org/schemas/1.0.0";
+const RENDER_OPTS = {
+    binName: "ory-copilot",
+    packageName: PACKAGE_NAME,
+};
+const EVENTS = [
+    "sessionStart",
+    "sessionEnd",
+    "userPromptSubmitted",
+    "preToolUse",
+    "postToolUse",
+    "postToolUseFailure",
+    "errorOccurred",
+    "subagentStart",
+    "subagentStop",
+];
+function readPackageVersion() {
+    const manifest = JSON.parse(fs.readFileSync(path.join(PACKAGE_ROOT, "package.json"), "utf8"));
+    return manifest.version;
+}
+function wireGitHubCopilotRuntime(args) {
+    return (0, argus_1.wireRuntime)({
+        harness: HARNESS,
+        packageName: PACKAGE_NAME,
+        packageRoot: PACKAGE_ROOT,
+        installCommand: "npx -y -p @ory/github-copilot ory-copilot install",
+        args,
+        fallbackStdout: "{}",
+    });
+}
+function installPluginAssets(root, runtime) {
+    fs.rmSync(root, { recursive: true, force: true });
+    fs.mkdirSync(root, { recursive: true });
+    fs.writeFileSync(path.join(root, "plugin.json"), JSON.stringify({
+        $schema: `${SCHEMA_ROOT}/plugin.schema.json`,
+        name: "ory-agent-security",
+        version: readPackageVersion(),
+        description: "Ory authentication, authorization, and activity auditing for GitHub Copilot CLI",
+        author: { name: "Ory" },
+        homepage: "https://www.ory.com",
+        repository: "https://github.com/ory/ory-agent-plugins",
+        license: "Apache-2.0",
+        keywords: ["ory", "copilot", "agent-security"],
+    }, null, 2) + "\n");
+    (0, argus_1.writeSkillTree)(path.join(root, "skills"), [
+        ...(0, argus_1.renderOrySkills)(HARNESS, RENDER_OPTS),
+        ...(0, argus_1.renderOryCommands)(HARNESS, RENDER_OPTS).map(argus_1.commandToSkill),
+    ]);
+    if (runtime.mcpServer) {
+        fs.writeFileSync(path.join(root, "mcp.json"), JSON.stringify({
+            $schema: `${SCHEMA_ROOT}/mcp.schema.json`,
+            mcpServers: {
+                ory: {
+                    type: "stdio",
+                    command: runtime.mcpServer.command,
+                    args: runtime.mcpServer.args,
+                },
+            },
+        }, null, 2) + "\n");
+    }
+    const command = (0, argus_1.requireHookCommand)(runtime);
+    const hooks = {};
+    for (const event of EVENTS) {
+        hooks[event] = [
+            {
+                type: "command",
+                command: `${command} ${event}`,
+                timeoutSec: event === "sessionStart"
+                    ? (0, argus_1.sessionStartHookTimeout)(HARNESS, "seconds")
+                    : (0, argus_1.toolHookTimeout)(HARNESS, "seconds"),
+            },
+        ];
+    }
+    const hooksDir = path.join(root, "com.github.copilot", "hooks");
+    fs.mkdirSync(hooksDir, { recursive: true });
+    fs.writeFileSync(path.join(hooksDir, "hooks.json"), JSON.stringify({ version: 1, hooks }, null, 2) + "\n");
+}

package/dist/cli/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/main.js

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+"use strict";
+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 node_child_process_1 = require("node:child_process");
+const argus_1 = require("@ory/argus");
+const assets_js_1 = require("./assets.js");
+const HARNESS = "github-copilot";
+const BIN = "ory-copilot";
+const PACKAGE_ROOT = path.resolve(__dirname, "..", "..");
+const PLUGIN_DIR = path.join((0, argus_1.getHarnessDataDir)(HARNESS), "plugin");
+const SPAWN_VIA_SHELL = process.platform === "win32";
+function runCopilot(args) {
+    return (0, node_child_process_1.spawnSync)("copilot", args, {
+        encoding: "utf8",
+        stdio: "inherit",
+        shell: SPAWN_VIA_SHELL,
+    });
+}
+function install(args) {
+    if (args.includes("--print")) {
+        console.log(`Would install an Agent Plugins 1.0 bundle from ${PLUGIN_DIR}`);
+        return;
+    }
+    const runtime = (0, assets_js_1.wireGitHubCopilotRuntime)(args);
+    (0, assets_js_1.installPluginAssets)(PLUGIN_DIR, runtime);
+    const result = runCopilot(["plugin", "install", PLUGIN_DIR]);
+    if (result.error || result.status !== 0) {
+        throw new Error("`copilot plugin install` failed; GitHub Copilot CLI 1.0 or later is required");
+    }
+    console.log(`Installed the Ory Agent Security plugin from ${PLUGIN_DIR}.`);
+    (0, argus_1.printEnvHelp)(BIN);
+}
+function uninstall() {
+    const result = runCopilot(["plugin", "uninstall", "ory-agent-security"]);
+    if (result.error)
+        console.warn("GitHub Copilot CLI was not found; continuing local cleanup.");
+    fs.rmSync(PLUGIN_DIR, { recursive: true, force: true });
+    (0, argus_1.removeRuntimeWiring)(HARNESS);
+    for (const pruned of (0, argus_1.pruneRuntimeStores)())
+        console.log(`  Removed runtime: ${pruned}`);
+}
+async function status() {
+    await (0, argus_1.runStatusCommand)(BIN, HARNESS, {
+        title: "GitHub Copilot CLI",
+        printPluginSection: () => {
+            console.log("Plugin:");
+            console.log(`  Bundle:  ${fs.existsSync(path.join(PLUGIN_DIR, "plugin.json")) ? PLUGIN_DIR : "not installed"}`);
+            console.log(`  Runtime: ${(0, argus_1.describeRuntimeHealth)((0, argus_1.checkRuntimeHealth)(HARNESS))}`);
+        },
+    });
+}
+function help() {
+    console.log(`
+ory-copilot - Ory plugin for GitHub Copilot CLI
+
+Usage:
+  npx -y -p @ory/github-copilot ory-copilot <command> [options]
+
+Commands:
+  install       Materialize and install the Agent Plugins 1.0 bundle
+  uninstall     Remove the Copilot plugin and its Ory runtime wiring
+  configure     Set or view the Ory Agent Security connection
+  agent <cmd>   Inspect runtime identity state
+  permissions   Show live mode and native allowed/blocked state
+  status        Show plugin and runtime status
+  watch         Follow the activity/debug log
+  version       Show package and build versions
+  local <cmd>   Manage the local Ory dev environment
+`);
+}
+function main() {
+    const [command, ...args] = process.argv.slice(2);
+    if ((0, argus_1.shouldPrintHelp)(command, args))
+        return help();
+    switch (command) {
+        case "install":
+            (0, argus_1.beginDeferNextSteps)();
+            install(args);
+            void (0, argus_1.runPostInstall)(BIN, HARNESS, args).then(() => process.exit(0), (err) => { console.error(err.message ?? err); process.exit(1); });
+            break;
+        case "uninstall":
+            uninstall();
+            void (0, argus_1.clearCredentialsForUninstall)({ harness: HARNESS, purge: args.includes("--purge") }).then(() => process.exit(0), (err) => { console.error(err.message ?? err); process.exit(1); });
+            break;
+        case "configure":
+            (0, argus_1.runConfigureCommand)(BIN, args);
+            break;
+        case "agent":
+            void (0, argus_1.runAgentCommand)(BIN, HARNESS, args).then((code) => process.exit(code), (err) => { console.error(err.message ?? err); process.exit(1); });
+            break;
+        case "permissions":
+            void (0, argus_1.runPermissionsCommand)(BIN, HARNESS, args).then((code) => process.exit(code), (err) => { console.error(err.message ?? err); process.exit(1); });
+            break;
+        case "status":
+            void status().then(() => process.exit(0), (err) => { console.error(err.message ?? err); process.exit(1); });
+            break;
+        case "watch":
+            void (0, argus_1.runWatchCommand)(BIN, HARNESS, args).then((code) => process.exit(code), (err) => { console.error(err.message ?? err); process.exit(1); });
+            break;
+        case "local":
+            void (0, argus_1.runLocalCommand)(BIN, args).catch((err) => { console.error(err.message ?? err); process.exit(1); });
+            break;
+        case "version":
+        case "--version":
+        case "-v": process.exit((0, argus_1.runVersionCommand)(BIN, args, { packageRoot: PACKAGE_ROOT }));
+        case "help":
+        case "--help":
+        case "-h":
+        case undefined:
+            help();
+            break;
+        default:
+            console.error(`Unknown command: ${command}`);
+            help();
+            process.exit(1);
+    }
+}
+try {
+    main();
+}
+catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+}

package/dist/handlers.d.ts

@@ -0,0 +1,8 @@
+import { OryAgentClient, ensureAgentIdentity, ensureSubAgentIdentity, ensureUserAuthenticated } from "@ory/argus";
+import type { GitHubCopilotHookEvent, GitHubCopilotHookInput, GitHubCopilotHookOutput } from "./types.js";
+export interface HandleHookEventDeps {
+    userLogin?: typeof ensureUserAuthenticated;
+    agentGate?: typeof ensureAgentIdentity;
+    subAgentGate?: typeof ensureSubAgentIdentity;
+}
+export declare function handleHookEvent(event: GitHubCopilotHookEvent, input: GitHubCopilotHookInput, client: OryAgentClient, deps?: HandleHookEventDeps): Promise<GitHubCopilotHookOutput>;

package/dist/handlers.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleHookEvent = handleHookEvent;
+const argus_1 = require("@ory/argus");
+const HARNESS = "github-copilot";
+function toolArgs(input) {
+    if (typeof input.toolArgs !== "string")
+        return input.toolArgs;
+    try {
+        return JSON.parse(input.toolArgs);
+    }
+    catch {
+        return input.toolArgs;
+    }
+}
+async function handleHookEvent(event, input, client, deps = {}) {
+    client.logger.debug("hook.received", {
+        event,
+        sessionId: input.sessionId,
+        toolName: input.toolName,
+    });
+    return (0, argus_1.withHookContext)(client, { sessionId: input.sessionId }, async () => {
+        switch (event) {
+            case "sessionStart":
+                await (0, argus_1.sessionStart)(client, {
+                    binName: "ory-copilot",
+                    harness: HARNESS,
+                    userLogin: deps.userLogin,
+                    agentGate: deps.agentGate,
+                    activityAttributes: { source: input.source },
+                });
+                return {};
+            case "preToolUse": {
+                const result = await (0, argus_1.gate)(client, {
+                    harness: HARNESS,
+                    toolName: input.toolName ?? "unknown",
+                    toolArgs: toolArgs(input),
+                    subjectFallback: input.sessionId ? `session:${input.sessionId}` : undefined,
+                });
+                return result.blocked
+                    ? {
+                        permissionDecision: "deny",
+                        permissionDecisionReason: result.denialMessage,
+                    }
+                    : {};
+            }
+            case "postToolUse":
+                (0, argus_1.complete)(client, {
+                    toolName: input.toolName ?? "unknown",
+                    input: toolArgs(input),
+                    output: input.toolResult?.textResultForLlm,
+                });
+                return {};
+            case "postToolUseFailure":
+                (0, argus_1.fail)(client, {
+                    toolName: input.toolName ?? "unknown",
+                    input: toolArgs(input),
+                    error: input.error,
+                });
+                return {};
+            case "userPromptSubmitted":
+                client.logger.activity("user.prompt", "ok", {
+                    attributes: { promptLen: input.prompt?.length },
+                });
+                return {};
+            case "subagentStart": {
+                const subAgentType = input.agentName ?? input.agentType;
+                client.logger.activity("subagent.start", "ok", {
+                    attributes: { subAgentType, subAgentId: input.agentId },
+                });
+                if (subAgentType && (0, argus_1.isSecurityConnected)()) {
+                    await (0, argus_1.registerSubagent)(client, {
+                        harness: HARNESS,
+                        subAgentType,
+                        perSpawnId: input.agentId,
+                        subAgentGate: deps.subAgentGate,
+                    });
+                }
+                return {};
+            }
+            case "subagentStop":
+                client.logger.activity("subagent.stop", "ok", {
+                    attributes: {
+                        subAgentType: input.agentName ?? input.agentType,
+                        subAgentId: input.agentId,
+                        stopReason: input.stopReason,
+                    },
+                });
+                return {};
+            case "errorOccurred":
+                client.logger.activity("session.error", "error", {
+                    attributes: {
+                        errorContext: input.errorContext,
+                        recoverable: input.recoverable,
+                    },
+                });
+                return {};
+            case "sessionEnd":
+                client.logger.activity("session.end", "ok", {
+                    attributes: { reason: input.reason },
+                });
+                return {};
+            default:
+                client.logger.activity("hook.passthrough", "skipped", {
+                    attributes: { event },
+                });
+                return {};
+        }
+    });
+}

package/dist/hook.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { OryAgentClient } from "@ory/argus";
+import { handleHookEvent } from "./handlers.js";
+import type { GitHubCopilotHookEvent } from "./types.js";
+type HookHandler = typeof handleHookEvent;
+export declare function processHookInput(event: GitHubCopilotHookEvent, rawInput: string, hookClient: OryAgentClient, handler?: HookHandler): Promise<string>;
+export declare function main(): Promise<void>;
+export {};

package/dist/hook.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processHookInput = processHookInput;
+exports.main = main;
+const argus_1 = require("@ory/argus");
+const handlers_js_1 = require("./handlers.js");
+const FAIL_OPEN = {};
+const EVENT_FLUSH_TIMEOUT_MS = 750;
+let client;
+async function readStdin() {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        process.stdin.on("data", (chunk) => chunks.push(chunk));
+        process.stdin.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+        process.stdin.on("error", reject);
+    });
+}
+async function flushEvents() {
+    try {
+        await client?.flushEvents(EVENT_FLUSH_TIMEOUT_MS);
+    }
+    catch {
+        // Activity delivery never changes the hook decision.
+    }
+}
+async function processHookInput(event, rawInput, hookClient, handler = handlers_js_1.handleHookEvent) {
+    let input;
+    try {
+        input = JSON.parse(rawInput);
+    }
+    catch (err) {
+        hookClient.logger.error("hook.stdin.parse_failed", {
+            message: err instanceof Error ? err.message : String(err),
+        });
+        return JSON.stringify(FAIL_OPEN);
+    }
+    try {
+        return JSON.stringify(await handler(event, input, hookClient));
+    }
+    catch (err) {
+        hookClient.logger.error("hook.handler.error", {
+            event,
+            message: err instanceof Error ? err.message : String(err),
+        });
+        return JSON.stringify(FAIL_OPEN);
+    }
+}
+async function main() {
+    client = argus_1.OryAgentClient.fromEnv("github-copilot");
+    const event = process.argv[2];
+    if (!event)
+        throw new Error("Missing GitHub Copilot hook event argument");
+    process.stdout.write(await processHookInput(event, await readStdin(), client));
+    await flushEvents();
+}
+if (require.main === module) {
+    main().then(() => process.exit(0), async (err) => {
+        process.stderr.write(`[ory-agent] fatal: ${err}\n`);
+        process.stdout.write(JSON.stringify(FAIL_OPEN));
+        await flushEvents();
+        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 { GitHubCopilotHookEvent, GitHubCopilotHookInput, GitHubCopilotHookOutput, } from "./types.js";
+export { installPluginAssets } from "./cli/assets.js";

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installPluginAssets = 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, "installPluginAssets", { enumerable: true, get: function () { return assets_js_1.installPluginAssets; } });

package/dist/types.d.ts

@@ -0,0 +1,39 @@
+/** GitHub Copilot CLI's native camelCase command-hook contract. */
+export interface GitHubCopilotHookInput {
+    sessionId?: string;
+    timestamp?: number;
+    cwd?: string;
+    source?: "startup" | "resume" | "new" | string;
+    initialPrompt?: string;
+    prompt?: string;
+    toolName?: string;
+    /** Copilot may deliver this as an object or as a JSON string. */
+    toolArgs?: unknown;
+    toolResult?: {
+        resultType?: string;
+        textResultForLlm?: string;
+    };
+    error?: string | {
+        message?: string;
+        name?: string;
+        stack?: string;
+    };
+    errorContext?: string;
+    recoverable?: boolean;
+    reason?: string;
+    transcriptPath?: string;
+    agentId?: string;
+    agentType?: string;
+    agentName?: string;
+    agentDisplayName?: string;
+    agentDescription?: string;
+    response?: string;
+    stopReason?: string;
+    [key: string]: unknown;
+}
+export type GitHubCopilotHookEvent = "sessionStart" | "sessionEnd" | "userPromptSubmitted" | "preToolUse" | "postToolUse" | "postToolUseFailure" | "errorOccurred" | "subagentStart" | "subagentStop" | string;
+export interface GitHubCopilotHookOutput {
+    permissionDecision?: "allow" | "deny" | "ask";
+    permissionDecisionReason?: string;
+    additionalContext?: string;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,65 @@
 {
   "name": "@ory/github-copilot",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.5.0",
+  "description": "Ory plugin for GitHub Copilot CLI: skills, local Ory tooling, and authentication, authorization, and audit for every tool call",
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/ory/ory-agent-plugins/tree/main/packages/github-copilot",
+  "bugs": {
+    "url": "https://github.com/ory/ory-agent-plugins/issues"
+  },
+  "keywords": [
+    "ory",
+    "github-copilot",
+    "copilot-cli",
+    "hooks",
+    "plugin",
+    "authentication",
+    "authorization",
+    "permissions",
+    "audit",
+    "agent-security",
+    "mcp"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/",
+    "provenance": true
+  },
+  "reova": {
+    "enabled": true,
+    "endpoint": "https://telemetry.reo.dev/data"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "ory-copilot": "dist/cli/main.js",
+    "ory-copilot-hook": "dist/hook.js"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.tsbuildinfo"
+  ],
+  "dependencies": {
+    "reova": "^0.7.0",
+    "@ory/argus": "1.5.0"
+  },
+  "devDependencies": {
+    "typescript": "^6.0.2"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist *.tsbuildinfo",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  }
 }