@ory/opencode 0.1.0

package/README.md

@@ -0,0 +1,100 @@
+# Ory Agent Plugin: OpenCode
+
+[Ory](https://ory.com) bundled into [OpenCode](https://opencode.ai): skills and markdown 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 OpenCode runs.
+
+## Install
+
+OpenCode loads plugins listed in the `plugin` array of `opencode.json` and fetches them from npm on next launch:
+
+```json
+{ "plugin": ["@ory/opencode"] }
+```
+
+Or use the Ory installer to register the plugin **and** the Ory MCP server in one step, with no prior `npm install` required:
+
+```bash
+npx @ory/opencode install                          # writes opencode.json + MCP config
+npx @ory/opencode install --project-dir <path>
+npx @ory/opencode uninstall
+```
+
+Either flow drops the Ory skill catalog into `.opencode/skills/` and the local-stack commands into `.opencode/commands/ory/`.
+
+## Developer experience
+
+This plugin 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 OpenCode to add Ory auth to your codebase. Each skill is a vetted, end-to-end playbook:
+
+- **`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 OpenCode to prototype and test against without a remote project.
+
+Skills are versioned with the plugin so guidance stays in sync as Ory APIs evolve.
+
+### Ory MCP server
+
+Bundled and registered by the Ory installer. It exposes the Ory CLI and the Ory Network REST API as MCP tools so OpenCode 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 plugin 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-opencode configure`) and the security features below run against the local stack.
+
+## Configure
+
+```bash
+npx ory-opencode 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 on the machine. Without it the plugin still loads cleanly and runs in **pass-through mode**: skills and commands work, but nothing is blocked.
+
+## Agent security (Argus)
+
+Once the plugin is pointed at an Ory project (local or hosted), OpenCode'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`; tokens refresh and a `user.auth` audit span is emitted at every session start. The OpenCode process (the **agent**) gets its own OAuth2 identity, self-registered via Dynamic Client Registration on first run.
+- **Authorization.** When OpenCode prompts for permission to use a tool, the plugin checks Ory Permissions against the user's subject and returns `allow` / `deny`. A parallel pre-tool check is recorded as part of the audit trail. 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 plugin 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.
+
+## Programmatic usage
+
+```typescript
+import { createOryPlugin } from "@ory/opencode";
+
+const plugin = createOryPlugin();
+```
+
+## CLI
+
+```
+npx ory-opencode install | uninstall              [--project-dir <path>]
+npx ory-opencode configure                         [--project-url <url>] [--api-key <key>] [--audit-only]
+npx ory-opencode agent <status|unregister>         Manage the agent's OAuth2 identity
+npx ory-opencode local <up|down|status|seed|logs|env|configure|reset>
+npx ory-opencode status                            [--project-dir <path>]
+```
+
+## Links
+
+- [ory.com](https://ory.com)
+
+## License
+
+Apache-2.0

package/dist/cli/assets.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Materialize / clean the Ory skill catalog and slash commands for the
+ * OpenCode plugin. Skills land at `<projectDir>/.opencode/skills/<name>/SKILL.md`
+ * (OpenCode auto-discovers them) and commands at
+ * `<projectDir>/.opencode/commands/ory/<slug>.md` so they're exposed under
+ * the `ory` namespace.
+ */
+export declare function installOpencodeOryAssets(projectDir: string): void;
+export declare function uninstallOpencodeOryAssets(projectDir: string): void;

package/dist/cli/assets.js

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * Materialize / clean the Ory skill catalog and slash commands for the
+ * OpenCode plugin. Skills land at `<projectDir>/.opencode/skills/<name>/SKILL.md`
+ * (OpenCode auto-discovers them) and commands at
+ * `<projectDir>/.opencode/commands/ory/<slug>.md` so they're exposed under
+ * the `ory` namespace.
+ */
+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.installOpencodeOryAssets = installOpencodeOryAssets;
+exports.uninstallOpencodeOryAssets = uninstallOpencodeOryAssets;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const argus_1 = require("@ory/argus");
+const RENDER_OPTS = {
+    binName: "ory-opencode",
+    packageName: "@ory/opencode",
+};
+const CMD_SUBDIR = "ory";
+function opencodeRoot(projectDir) {
+    return path.join(projectDir, ".opencode");
+}
+function installOpencodeOryAssets(projectDir) {
+    const root = opencodeRoot(projectDir);
+    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)("opencode", 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)("opencode", RENDER_OPTS)) {
+        fs.writeFileSync(path.join(cmdDir, `${cmd.slug}.md`), (0, argus_1.commandToFrontmatterMarkdown)(cmd));
+    }
+}
+function safeRmEmpty(dir) {
+    try {
+        if (fs.existsSync(dir) && fs.readdirSync(dir).length === 0) {
+            fs.rmdirSync(dir);
+        }
+    }
+    catch {
+        /* ignore */
+    }
+}
+function uninstallOpencodeOryAssets(projectDir) {
+    const root = opencodeRoot(projectDir);
+    if (!fs.existsSync(root))
+        return;
+    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}.md`);
+            if (fs.existsSync(f))
+                fs.unlinkSync(f);
+        }
+        safeRmEmpty(cmdDir);
+        safeRmEmpty(path.join(root, "commands"));
+    }
+    safeRmEmpty(root);
+}

package/dist/cli/main.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/**
+ * Main CLI for @ory/opencode.
+ *
+ * Usage:
+ *   npx ory-opencode install [--project-dir <path>]   Register plugin in opencode.json
+ *   npx ory-opencode uninstall                         Remove plugin from opencode.json
+ *   npx ory-opencode status                            Show plugin status
+ */
+export {};

package/dist/cli/main.js

@@ -0,0 +1,203 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Main CLI for @ory/opencode.
+ *
+ * Usage:
+ *   npx ory-opencode install [--project-dir <path>]   Register plugin in opencode.json
+ *   npx ory-opencode uninstall                         Remove plugin from opencode.json
+ *   npx ory-opencode 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 argus_1 = require("@ory/argus");
+const assets_js_1 = require("./assets.js");
+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-opencode", args);
+            break;
+        case "agent":
+            (0, argus_1.runAgentCommand)("ory-opencode", args).then((code) => process.exit(code), (err) => {
+                console.error(err.message ?? err);
+                process.exit(1);
+            });
+            break;
+        case "status":
+            status(args);
+            break;
+        case "local":
+            (0, argus_1.runLocalCommand)("ory-opencode", 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 parseProjectDir(args) {
+    const idx = args.indexOf("--project-dir");
+    if (idx !== -1 && args[idx + 1])
+        return args[idx + 1];
+    return process.cwd();
+}
+const PLUGIN_MODULE = "@ory/opencode";
+const MCP_SERVER_NAME = "ory";
+const MCP_SERVER_COMMAND = [
+    "npx",
+    "--package=@ory/mcp-server",
+    "ory-mcp-server",
+];
+function install(args) {
+    const projectDir = parseProjectDir(args);
+    const configPath = path.join(projectDir, "opencode.json");
+    const config = (0, argus_1.readJsonFile)(configPath);
+    const plugin = (config.plugin ?? []).filter((p) => (typeof p === "string" ? p : p[0]) !== PLUGIN_MODULE);
+    plugin.push(PLUGIN_MODULE);
+    config.plugin = plugin;
+    // OpenCode's config schema uses `mcp` (singular) with a `local` connector
+    // shape `{ type: "local", command: [...] }` — not the generic
+    // `mcpServers` / `{command, args}` form used by Claude Code.
+    const mcp = (config.mcp ?? {});
+    mcp[MCP_SERVER_NAME] = { type: "local", command: MCP_SERVER_COMMAND };
+    config.mcp = mcp;
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+    (0, assets_js_1.installOpencodeOryAssets)(projectDir);
+    console.log(`Ory plugin and MCP server registered in ${configPath}`);
+    console.log(`  Plugin: ${PLUGIN_MODULE}`);
+    console.log(`  MCP server: ${MCP_SERVER_NAME} (${MCP_SERVER_COMMAND.join(" ")})`);
+    console.log(`  Skills + commands installed under ${path.join(projectDir, ".opencode")}`);
+    (0, argus_1.printEnvHelp)("ory-opencode");
+}
+function uninstall(args) {
+    const projectDir = parseProjectDir(args);
+    const configPath = path.join(projectDir, "opencode.json");
+    if (!fs.existsSync(configPath)) {
+        console.log("No opencode.json found. Nothing to uninstall.");
+        return;
+    }
+    const config = (0, argus_1.readJsonFile)(configPath);
+    const plugin = (config.plugin ?? []).filter((p) => (typeof p === "string" ? p : p[0]) !== PLUGIN_MODULE);
+    if (plugin.length === 0) {
+        delete config.plugin;
+    }
+    else {
+        config.plugin = plugin;
+    }
+    const mcp = (config.mcp ?? {});
+    delete mcp[MCP_SERVER_NAME];
+    if (Object.keys(mcp).length === 0) {
+        delete config.mcp;
+    }
+    else {
+        config.mcp = mcp;
+    }
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+    (0, assets_js_1.uninstallOpencodeOryAssets)(projectDir);
+    console.log(`Ory plugin and MCP server removed from ${configPath}`);
+}
+function status(args) {
+    const projectDir = parseProjectDir(args);
+    const configPath = path.join(projectDir, "opencode.json");
+    console.log("Ory Agent Plugin Status (OpenCode)");
+    console.log("===================================");
+    console.log("");
+    // OpenCode-specific: check plugin registration
+    const config = (0, argus_1.readJsonFile)(configPath);
+    const moduleName = "@ory/opencode";
+    const plugin = (config.plugin ?? []);
+    const oryPlugin = plugin.find((p) => (typeof p === "string" ? p : p[0]) === moduleName);
+    console.log("Configuration:");
+    console.log(`  Config file: ${configPath}`);
+    console.log(`  Plugin registered: ${oryPlugin ? "yes" : "NO"}`);
+    if (oryPlugin) {
+        console.log(`  Module: ${typeof oryPlugin === "string" ? oryPlugin : oryPlugin[0]}`);
+    }
+    // Shared Ory config
+    console.log("");
+    console.log("Ory Configuration:");
+    const resolved = (0, argus_1.resolveConfig)();
+    const oryConfigPath = (0, argus_1.getConfigPath)();
+    console.log(`  Config file: ${oryConfigPath}`);
+    console.log(`  Project URL: ${resolved.projectUrl ?? "NOT SET"} [source: ${resolved.projectUrlSource}]`);
+    console.log(`  API Key:     ${resolved.apiKey ? "(set)" : "NOT SET"} [source: ${resolved.apiKeySource}]`);
+    (0, argus_1.printEnvironment)();
+    (0, argus_1.printLogTail)();
+}
+function help() {
+    console.log(`
+ory-opencode — Ory plugin for OpenCode
+
+Usage:
+  npx ory-opencode <command> [options]
+
+Commands:
+  install [--project-dir <path>]   Register the Ory plugin in opencode.json
+  uninstall [--project-dir <path>] Remove the Ory plugin from opencode.json
+  configure                        Set or view Ory project URL and API key
+  status [--project-dir <path>]    Show plugin configuration and status
+  local <cmd>                      Manage local Ory dev environment (up, down, status, seed, ...)
+
+After installing, the plugin hooks into these OpenCode lifecycle events:
+  session.created        Verify agent session via Ory Identities
+  tool.execute.before    Check tool permissions via Ory Permissions
+  tool.execute.after     Audit log tool executions
+  permission.ask         Authorize actions via Ory Permissions
+
+Examples:
+  npx ory-opencode install           # Register in current directory
+  npx ory-opencode status            # Check configuration
+  npx ory-opencode uninstall         # Remove plugin
+`);
+}
+main();

package/dist/cli/setup.d.ts

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

package/dist/cli/setup.js

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Setup CLI for the Ory OpenCode plugin.
+ *
+ * Usage:
+ *   npx ory-opencode-setup                    # Auto-detect and configure
+ *   npx ory-opencode-setup --project-dir /path/to/repo
+ *   npx ory-opencode-setup --print            # Print config to stdout without writing
+ *   npx ory-opencode-setup --uninstall        # Remove Ory plugin from config
+ */
+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 PLUGIN_MODULE = "@ory/opencode";
+const MCP_SERVER_NAME = "ory";
+const MCP_SERVER_COMMAND = [
+    "npx",
+    "--package=@ory/mcp-server",
+    "ory-mcp-server",
+];
+// OpenCode's config schema uses `mcp` (singular) with a `local` connector
+// shape `{ type: "local", command: [...] }`, not the generic `mcpServers`
+// helper from core.
+function mergeOpencodeMcp(existing) {
+    const merged = { ...existing };
+    const mcp = (merged.mcp ?? {});
+    mcp[MCP_SERVER_NAME] = { type: "local", command: MCP_SERVER_COMMAND };
+    merged.mcp = mcp;
+    return merged;
+}
+function removeOpencodeMcp(existing) {
+    const merged = { ...existing };
+    const mcp = (merged.mcp ?? {});
+    delete mcp[MCP_SERVER_NAME];
+    if (Object.keys(mcp).length === 0) {
+        delete merged.mcp;
+    }
+    else {
+        merged.mcp = mcp;
+    }
+    return merged;
+}
+function getConfigPath(args) {
+    return path.join(args.projectDir, "opencode.json");
+}
+function mergePlugin(existing) {
+    const merged = { ...existing };
+    const plugin = (merged.plugin ?? []).filter((p) => (typeof p === "string" ? p : p[0]) !== PLUGIN_MODULE);
+    plugin.push(PLUGIN_MODULE);
+    merged.plugin = plugin;
+    return merged;
+}
+function removePlugin(existing) {
+    const merged = { ...existing };
+    const plugin = (merged.plugin ?? []).filter((p) => (typeof p === "string" ? p : p[0]) !== PLUGIN_MODULE);
+    if (plugin.length === 0) {
+        delete merged.plugin;
+    }
+    else {
+        merged.plugin = plugin;
+    }
+    return merged;
+}
+function main() {
+    if (process.argv.includes("--help") || process.argv.includes("-h")) {
+        (0, argus_1.printSetupHelp)("ory-opencode-setup", "OpenCode");
+        process.exit(0);
+    }
+    const args = (0, argus_1.parseSetupArgs)();
+    if (args.print) {
+        console.log(JSON.stringify({ plugin: [PLUGIN_MODULE] }, null, 2));
+        return;
+    }
+    const configPath = getConfigPath(args);
+    const existing = (0, argus_1.readJsonFile)(configPath);
+    if (args.uninstall) {
+        if (!fs.existsSync(configPath)) {
+            console.log("No opencode.json found. Nothing to uninstall.");
+            return;
+        }
+        let updated = removePlugin(existing);
+        updated = removeOpencodeMcp(updated);
+        (0, argus_1.writeJsonFile)(configPath, updated);
+        (0, assets_js_1.uninstallOpencodeOryAssets)(args.projectDir);
+        console.log(`Removed Ory plugin and MCP server from ${configPath}`);
+        console.log(`Removed Ory skills and commands from ${path.join(args.projectDir, ".opencode")}`);
+        return;
+    }
+    let merged = mergePlugin(existing);
+    merged = mergeOpencodeMcp(merged);
+    (0, argus_1.writeJsonFile)(configPath, merged);
+    (0, assets_js_1.installOpencodeOryAssets)(args.projectDir);
+    console.log(`Ory plugin and MCP server configured in ${configPath}`);
+    console.log(`Ory skills and commands installed to ${path.join(args.projectDir, ".opencode")}`);
+    (0, argus_1.printNextSteps)("OpenCode", "npx ory-opencode-setup --uninstall");
+}
+main();

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { createOryPlugin } from "./plugin.js";
+export { createOryPlugin };
+declare const _default: import("./types.js").PluginModule;
+export default _default;

package/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOryPlugin = void 0;
+const plugin_js_1 = require("./plugin.js");
+Object.defineProperty(exports, "createOryPlugin", { enumerable: true, get: function () { return plugin_js_1.createOryPlugin; } });
+// OpenCode loads plugins via ESM import() and expects either a default-exported
+// Plugin function or a PluginModule object with a .server property.
+// eslint-disable-next-line import/no-default-export
+exports.default = (0, plugin_js_1.createOryPlugin)();

package/dist/plugin.d.ts

@@ -0,0 +1,24 @@
+import { OryAgentClient, ensureUserAuthenticated, ensureAgentIdentity } from "@ory/argus";
+import type { PluginModule } from "./types.js";
+export interface CreateOryPluginDeps {
+    /** Test injection point for the user auth gate. */
+    authGate?: typeof ensureUserAuthenticated;
+    /** Test injection point for the agent identity gate. */
+    agentGate?: typeof ensureAgentIdentity;
+}
+/**
+ * Create the Ory plugin module for OpenCode.
+ *
+ * OpenCode plugins export { server: Plugin } where Plugin receives
+ * context and returns a Hooks object. Hook functions use a mutating
+ * (input, output) => Promise<void> pattern.
+ *
+ * The `server` factory has no return-value channel for blocking, so the
+ * auth gate runs in advisory mode at startup — it emits the audit span,
+ * refreshes tokens, and may launch a browser flow when interactive, but
+ * cannot prevent the session from starting.
+ */
+export declare function createOryPlugin(clientOrConfig?: OryAgentClient | {
+    projectUrl: string;
+    apiKey?: string;
+}, deps?: CreateOryPluginDeps): PluginModule;

package/dist/plugin.js

@@ -0,0 +1,382 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOryPlugin = createOryPlugin;
+const argus_1 = require("@ory/argus");
+/**
+ * Create the Ory plugin module for OpenCode.
+ *
+ * OpenCode plugins export { server: Plugin } where Plugin receives
+ * context and returns a Hooks object. Hook functions use a mutating
+ * (input, output) => Promise<void> pattern.
+ *
+ * The `server` factory has no return-value channel for blocking, so the
+ * auth gate runs in advisory mode at startup — it emits the audit span,
+ * refreshes tokens, and may launch a browser flow when interactive, but
+ * cannot prevent the session from starting.
+ */
+function createOryPlugin(clientOrConfig, deps = {}) {
+    return {
+        id: "ory",
+        server: async (_input, options) => {
+            const client = clientOrConfig instanceof argus_1.OryAgentClient
+                ? clientOrConfig
+                : clientOrConfig
+                    ? new argus_1.OryAgentClient({
+                        ...clientOrConfig,
+                        harness: "opencode",
+                    })
+                    : argus_1.OryAgentClient.fromEnv("opencode");
+            // Log session status on startup (never blocks)
+            await verifyOnStartup(client, deps);
+            return {
+                config: createConfigHandler(client),
+                "chat.message": createChatMessageHandler(client),
+                "command.execute.before": createCommandBeforeHandler(client),
+                "permission.ask": createPermissionHandler(client, options),
+                "tool.execute.before": createToolBeforeHandler(client),
+                "tool.execute.after": createToolAfterHandler(client),
+            };
+        },
+    };
+}
+// ─── config ────────────────────────────────────────────────────────
+function createConfigHandler(client) {
+    return async (_input) => {
+        client.logger.info("lifecycle.config", {
+            projectUrl: (0, argus_1.resolveConfig)().projectUrl,
+            auditOnly: (0, argus_1.resolveConfig)().auditOnly,
+        });
+        client.tracer.record("config.resolve", "ok", {
+            attributes: {
+                projectUrl: (0, argus_1.resolveConfig)().projectUrl,
+                auditOnly: (0, argus_1.resolveConfig)().auditOnly,
+            },
+        });
+    };
+}
+// ─── chat.message ──────────────────────────────────────────────────
+function createChatMessageHandler(client) {
+    return async (input, _output) => {
+        client.tracer.setContext({
+            traceId: (0, argus_1.deriveTraceId)(input.sessionID),
+            sessionId: input.sessionID,
+        });
+        client.logger.info("lifecycle.chat_message", {
+            sessionID: input.sessionID,
+            messageID: input.messageID,
+            agent: input.agent,
+            providerID: input.model?.providerID,
+            modelID: input.model?.modelID,
+        });
+        client.tracer.record("user.prompt", "ok", {
+            attributes: {
+                messageID: input.messageID,
+                agent: input.agent,
+                providerID: input.model?.providerID,
+                modelID: input.model?.modelID,
+            },
+        });
+    };
+}
+// ─── command.execute.before ────────────────────────────────────────
+function createCommandBeforeHandler(client) {
+    return async (input, _output) => {
+        if (input.sessionID) {
+            client.tracer.setContext({
+                traceId: (0, argus_1.deriveTraceId)(input.sessionID),
+                sessionId: input.sessionID,
+            });
+        }
+        client.logger.info("lifecycle.command_execute_before", {
+            command: input.name,
+            sessionID: input.sessionID,
+        });
+        client.tracer.record("hook.receive", "ok", {
+            attributes: {
+                event: "command.execute.before",
+                command: input.name,
+            },
+        });
+    };
+}
+// ─── Session verification on startup ────────────────────────────────
+async function verifyOnStartup(client, deps) {
+    // Run the user auth gate. The OpenCode `server` factory has no block
+    // primitive, so allowBlock is false — the gate emits the user.auth
+    // audit span, refreshes tokens, and may prompt the user, but never
+    // prevents the session from starting. When ORY_AUTH_GATE is unset the
+    // gate is a no-op (mode === "disabled") and we fall through to legacy
+    // logging.
+    const userGate = deps.authGate ?? argus_1.ensureUserAuthenticated;
+    const decision = await userGate(client, {
+        binName: "ory-opencode",
+        harness: "opencode",
+        allowBlock: false,
+    });
+    // Resolve the agent identity (machine credentials). Never blocks;
+    // attaches the agent's bearer token to outgoing Ory API calls.
+    const agentGate = deps.agentGate ?? argus_1.ensureAgentIdentity;
+    await agentGate(client, { projectUrl: (0, argus_1.resolveConfig)().projectUrl, harness: "opencode" });
+    if (decision.mode !== "disabled") {
+        return;
+    }
+    const resolved = (0, argus_1.resolveConfig)();
+    if (resolved.auditOnly) {
+        client.logger.info("config.audit_only", {
+            message: "Audit-only mode enabled. Auth and permission checks are disabled.",
+        });
+        return;
+    }
+    if (!resolved.projectUrl) {
+        client.logger.warn("config.not_configured", {
+            message: "Ory plugin is not configured. Auth and permission checks are disabled. " +
+                "Run 'npx ory-opencode configure' to connect to an Ory project.",
+        });
+        return;
+    }
+    const sessionToken = process.env.ORY_SESSION_TOKEN;
+    const oauth2Token = process.env.ORY_OAUTH2_TOKEN;
+    if (sessionToken) {
+        try {
+            const session = await client.verifySession(sessionToken);
+            if (!session.active) {
+                client.logger.warn("session.inactive", {
+                    message: "Ory session is not active. Re-authenticate to enable auth checks.",
+                });
+            }
+        }
+        catch (err) {
+            const oryErr = err;
+            client.logger.warn("session.verify_failed", {
+                code: isOryError(err) ? oryErr.code : "unknown",
+                message: err instanceof Error ? err.message : String(err),
+            });
+        }
+        return;
+    }
+    if (oauth2Token) {
+        try {
+            const tokenInfo = await client.introspectToken(oauth2Token);
+            if (!tokenInfo.active) {
+                client.logger.warn("oauth2.token_inactive", {
+                    message: "Ory OAuth2 token is not active. Obtain a new token to enable auth checks.",
+                });
+                return;
+            }
+            client.logger.info("oauth2.session_authenticated", {
+                clientId: tokenInfo.clientId,
+                subject: tokenInfo.subject,
+            });
+        }
+        catch (err) {
+            const oryErr = err;
+            client.logger.warn("oauth2.introspect_failed", {
+                code: isOryError(err) ? oryErr.code : "unknown",
+                message: err instanceof Error ? err.message : String(err),
+            });
+        }
+        return;
+    }
+    client.logger.warn("session.no_credentials", {
+        message: "Neither ORY_SESSION_TOKEN nor ORY_OAUTH2_TOKEN is set. " +
+            "Skipping authentication.",
+    });
+}
+// ─── permission.ask ─────────────────────────────────────────────────
+function createPermissionHandler(client, _options) {
+    return async (input, output) => {
+        client.logger.info("lifecycle.permission_ask", {
+            toolID: input.toolID,
+            title: input.title,
+        });
+        // In audit-only mode, defer to user prompt
+        if ((0, argus_1.resolveConfig)().auditOnly) {
+            return;
+        }
+        const subject = (0, argus_1.resolveUserSubject)(client, "agent:opencode");
+        const mcpTool = (0, argus_1.parseMcpToolGeneric)(input.toolID);
+        try {
+            if (mcpTool) {
+                const mcpResult = await (0, argus_1.checkMcpPermission)(client, mcpTool, {
+                    subject,
+                    spanAttributes: { toolName: input.toolID },
+                });
+                output.status = mcpResult.allowed ? "allow" : "deny";
+                return;
+            }
+            const result = await client.checkPermission({
+                namespace: resolveNamespace(),
+                object: input.toolID,
+                relation: "use",
+                ...subject,
+            }, { spanAttributes: { toolName: input.toolID } });
+            output.status = result.allowed ? "allow" : "deny";
+        }
+        catch (err) {
+            if (isOryError(err) && (err.code === "network_error" || err.code === "rate_limited")) {
+                client.logger.warn("permission.fallback", {
+                    toolID: input.toolID,
+                    code: err.code,
+                });
+                // Leave output.status as "ask" (default)
+                return;
+            }
+            // For other errors, also fall back to ask
+            output.status = "ask";
+        }
+    };
+}
+// ─── tool.execute.before ────────────────────────────────────────────
+function createToolBeforeHandler(client) {
+    return async (input, output) => {
+        client.logger.info("lifecycle.tool_execute_before", {
+            tool: input.tool,
+            sessionID: input.sessionID,
+            callID: input.callID,
+        });
+        // Set trace context for this tool invocation
+        client.tracer.setContext({
+            traceId: (0, argus_1.deriveTraceId)(input.sessionID),
+            sessionId: input.sessionID,
+        });
+        const inputSummary = (0, argus_1.summarizeToolInput)(input.tool, output.args);
+        // In audit-only mode, log the invocation but skip permission checks
+        if ((0, argus_1.resolveConfig)().auditOnly) {
+            client.tracer.record("tool.invoke", "ok", {
+                attributes: { toolName: input.tool, ...inputSummary },
+            });
+            return;
+        }
+        const subject = (0, argus_1.resolveUserSubject)(client, input.sessionID ? `session:${input.sessionID}` : "agent:opencode");
+        const subjectId = (0, argus_1.subjectLabel)(subject);
+        const mcpTool = (0, argus_1.parseMcpToolGeneric)(input.tool);
+        try {
+            if (mcpTool) {
+                const mcpResult = await (0, argus_1.checkMcpPermission)(client, mcpTool, {
+                    subject,
+                    spanAttributes: { toolName: input.tool },
+                });
+                if (!mcpResult.allowed) {
+                    client.tracer.record("tool.block", "denied", {
+                        attributes: { toolName: input.tool, mcpServer: mcpTool.serverName, mcpTool: mcpTool.toolName, ...inputSummary, ...(0, argus_1.alertAttributes)(false) },
+                    });
+                    const message = (0, argus_1.formatDenialMessage)({
+                        tool: input.tool,
+                        subjectId,
+                        mcp: mcpTool,
+                    });
+                    client.logger.warn("tool.denied", {
+                        tool: input.tool,
+                        subjectId,
+                        message,
+                    });
+                    // OpenCode has no native block signal in tool.execute.before;
+                    // throwing aborts execution (documented .env-protection pattern)
+                    // and surfaces error.message back to the agent.
+                    throw new argus_1.OryDenialError({
+                        tool: input.tool,
+                        subjectId,
+                        mcp: mcpTool,
+                    });
+                }
+                client.tracer.record("tool.invoke", "ok", {
+                    attributes: { toolName: input.tool, mcpServer: mcpTool.serverName, mcpTool: mcpTool.toolName, ...inputSummary },
+                });
+                return;
+            }
+            const namespace = resolveNamespace();
+            const result = await client.checkPermission({
+                namespace,
+                object: input.tool,
+                relation: "use",
+                ...subject,
+            }, { spanAttributes: { toolName: input.tool } });
+            if (!result.allowed) {
+                client.tracer.record("tool.block", "denied", {
+                    attributes: { toolName: input.tool, ...inputSummary, allowed: result.allowed, ...(0, argus_1.alertAttributes)(false) },
+                });
+                const message = (0, argus_1.formatDenialMessage)({
+                    tool: input.tool,
+                    subjectId,
+                    namespace,
+                });
+                client.logger.warn("tool.denied", {
+                    tool: input.tool,
+                    subjectId,
+                    message,
+                });
+                throw new argus_1.OryDenialError({
+                    tool: input.tool,
+                    subjectId,
+                    namespace,
+                });
+            }
+            client.tracer.record("tool.invoke", "ok", {
+                attributes: { toolName: input.tool, ...inputSummary, allowed: result.allowed },
+            });
+        }
+        catch (err) {
+            if (err instanceof argus_1.OryDenialError)
+                throw err;
+            handlePermissionError(err, input.tool, client);
+        }
+    };
+}
+// ─── tool.execute.after ─────────────────────────────────────────────
+function createToolAfterHandler(client) {
+    return async (input, output) => {
+        client.logger.info("lifecycle.tool_execute_after", {
+            tool: input.tool,
+            sessionID: input.sessionID,
+            callID: input.callID,
+        });
+        // Set trace context for this tool completion
+        client.tracer.setContext({
+            traceId: (0, argus_1.deriveTraceId)(input.sessionID),
+            sessionId: input.sessionID,
+        });
+        client.tracer.record("tool.complete", "ok", {
+            attributes: {
+                toolName: input.tool,
+                ...(0, argus_1.summarizeToolInput)(input.tool, input.args),
+                ...(0, argus_1.summarizeToolOutput)(input.tool, {
+                    title: output.title,
+                    output: output.output,
+                }),
+            },
+        });
+    };
+}
+// ─── Helpers ────────────────────────────────────────────────────────
+function resolveNamespace() {
+    return process.env.ORY_PERMISSION_NAMESPACE ?? "AgentTools";
+}
+function isOryError(err) {
+    return (typeof err === "object" &&
+        err !== null &&
+        "code" in err &&
+        "message" in err);
+}
+function handlePermissionError(err, tool, client) {
+    if (isOryError(err)) {
+        if (err.code === "network_error" || err.code === "rate_limited") {
+            client.logger.warn("permission.fallback", {
+                tool,
+                code: err.code,
+                message: "Failing open",
+            });
+            return;
+        }
+        client.logger.error("permission.check.error", {
+            tool,
+            code: err.code,
+            message: err.message,
+        });
+    }
+    else {
+        client.logger.error("permission.check.error", {
+            tool,
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,77 @@
+/**
+ * OpenCode plugin types.
+ *
+ * OpenCode plugins export { server: Plugin } where Plugin is a function
+ * that receives context and returns a Hooks object. Hook functions use
+ * a mutating (input, output) pattern.
+ *
+ * See: @opencode-ai/plugin for canonical types.
+ */
+export interface PluginInput {
+    client: unknown;
+    project: {
+        id: string;
+        path: string;
+        [key: string]: unknown;
+    };
+    directory: string;
+    worktree: string;
+    serverUrl: URL;
+}
+export type PluginOptions = Record<string, unknown>;
+export type Plugin = (input: PluginInput, options?: PluginOptions) => Promise<Hooks>;
+export interface PluginModule {
+    id?: string;
+    server: Plugin;
+}
+export interface Permission {
+    toolID: string;
+    title: string;
+    description: string;
+    metadata: Record<string, unknown>;
+}
+export interface ChatMessageInput {
+    sessionID: string;
+    messageID?: string;
+    agent?: string;
+    model?: {
+        providerID?: string;
+        modelID?: string;
+    };
+}
+export interface CommandExecuteBeforeInput {
+    name: string;
+    sessionID?: string;
+    args?: unknown;
+}
+export interface Hooks {
+    event?: (input: {
+        event: unknown;
+    }) => Promise<void>;
+    /** Fires when OpenCode loads its configuration. Observer only. */
+    config?: (input: Record<string, unknown>) => Promise<void>;
+    /** Fires on every user message. Observer only — useful for per-turn audit. */
+    "chat.message"?: (input: ChatMessageInput, output: Record<string, unknown>) => Promise<void>;
+    /** Fires before a slash command runs. Observer only. */
+    "command.execute.before"?: (input: CommandExecuteBeforeInput, output: Record<string, unknown>) => Promise<void>;
+    "permission.ask"?: (input: Permission, output: {
+        status: "ask" | "deny" | "allow";
+    }) => Promise<void>;
+    "tool.execute.before"?: (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        args: unknown;
+    }) => Promise<void>;
+    "tool.execute.after"?: (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+        args: unknown;
+    }, output: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    }) => Promise<void>;
+}

package/dist/types.js

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * OpenCode plugin types.
+ *
+ * OpenCode plugins export { server: Plugin } where Plugin is a function
+ * that receives context and returns a Hooks object. Hook functions use
+ * a mutating (input, output) pattern.
+ *
+ * See: @opencode-ai/plugin for canonical types.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@ory/opencode",
+  "version": "0.1.0",
+  "description": "Ory plugin for OpenCode: scaffolding skills, a local Ory instance, and authentication, authorization, and audit for every tool call",
+  "license": "Apache-2.0",
+  "homepage": "https://ory.com",
+  "keywords": [
+    "ory",
+    "opencode",
+    "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",
+    "tracing",
+    "distributed-tracing",
+    "observability",
+    "kratos",
+    "keto",
+    "hydra"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "opencode": "dist/cli/main.js",
+    "ory-opencode": "dist/cli/main.js",
+    "ory-opencode-setup": "dist/cli/setup.js"
+  },
+  "files": [
+    "dist",
+    "!dist/dev",
+    "!dist/**/*.tsbuildinfo"
+  ],
+  "dependencies": {
+    "@ory/argus": "0.1.0"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist *.tsbuildinfo",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "dev": "node dist/dev/launcher.js"
+  }
+}