@ory/mcp-server 0.14.0 → 1.0.1

package/README.md

@@ -9,7 +9,7 @@ Every Ory agent plugin in this repo registers it for you, but it's a standalone
 The server speaks MCP over stdio and registers ~50 tools across two execution paths:
 
 - **CLI-backed tools** shell out to the `ory` binary on your `PATH` (`--format json`). They cover identities, OAuth2 clients, relationships / permissions, projects, configuration, workspaces, organizations, JWKs, and event streams.
-- **`ory_api_request`** calls the Ory Network REST API directly over HTTP. Use it for any endpoint the dedicated tools don't cover (self-service flows, sessions, recovery codes, consent challenges, schemas). The CLI isn't required for this tool; just a base URL and API key.
+- **`ory_api_request`** calls the Ory Network REST API directly over HTTP. Use it for any endpoint the dedicated tools don't cover (self-service flows, sessions, recovery codes, consent challenges, schemas). The base URL comes from the `ory` CLI's selected project unless you pin one, so this tool needs no configuration of its own; an API key is only required for endpoints that demand an admin credential.
 
 All logging goes to stderr; stdout is reserved for the MCP protocol.
 
@@ -17,7 +17,7 @@ All logging goes to stderr; stdout is reserved for the MCP protocol.
 
 - **Node.js ≥ 22.**
 - **The `ory` CLI on `PATH`** for the CLI-backed tools. Install from [ory.com/docs/guides/cli/installation](https://www.ory.com/docs/guides/cli/installation), then authenticate with `ory auth`. (Set `ORY_CLI_PATH` if the binary lives elsewhere.)
-- **`ORY_PROJECT_URL` + `ORY_API_KEY`** for the `ory_api_request` tool.
+- **Nothing extra** for the `ory_api_request` tool — it falls back to the CLI's selected project for the base URL. Set `ORY_PROJECT_URL` to pin one, and `ORY_API_KEY` only for admin endpoints.
 
 ## Install
 
@@ -69,14 +69,14 @@ CLI-backed tools accept optional `project` and `workspace` parameters; defaults
 | `ORY_PROJECT` | _(none)_ | Default project ID/slug for CLI tools |
 | `ORY_WORKSPACE` | _(none)_ | Default workspace ID/name for CLI tools |
 | `ORY_CLI_TIMEOUT` | `30000` | CLI command timeout (ms) |
-| `ORY_PROJECT_URL` | _(none)_ | Base URL for `ory_api_request` |
+| `ORY_PROJECT_URL` | _the `ory` CLI's selected project_ | Base URL for `ory_api_request`. Unset, the tool asks the CLI which project is selected (`ory use project`) and derives `https://<slug>.projects.oryapis.com` from it. `ORY_PROJECT` pins which project is looked up. |
 | `ORY_SDK_URL` | _(none)_ | Fallback base URL for `ory_api_request` when `ORY_PROJECT_URL` is unset |
-| `ORY_API_KEY` | _(none)_ | Bearer token for `ory_api_request` |
+| `ORY_API_KEY` | _(none)_ | Bearer token for `ory_api_request`. Only needed for endpoints requiring an admin credential — the CI/headless path, not the default. |
 | `ORY_ACCESS_TOKEN` | _(none)_ | Fallback bearer for `ory_api_request` when `ORY_API_KEY` is unset |
 | `ORY_HTTP_TIMEOUT` | `30000` | REST request timeout (ms) |
 | `ORY_MCP_DEBUG` | `false` | Set to `true` for structured debug logging on stderr |
 
-Per-call parameters on `ory_api_request` (`base_url`, `api_key`) override the corresponding env vars.
+Per-call parameters on `ory_api_request` (`base_url`, `api_key`) override the corresponding env vars, and the env vars override the CLI fallback.
 
 ### Trusted hosts for `ory_api_request`
 

package/dist/tools/api.d.ts

@@ -10,6 +10,8 @@ interface ApiCallParams {
     query?: Record<string, string>;
     api_key?: string;
 }
+/** Drop the cached CLI lookup. For tests. */
+export declare function resetProjectUrlCache(): void;
 /**
  * Credential-attachment guard.
  *

package/dist/tools/api.js

@@ -1,15 +1,99 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetProjectUrlCache = resetProjectUrlCache;
 exports.isTrustedOryOrigin = isTrustedOryOrigin;
 exports.executeApiCall = executeApiCall;
 exports.registerApiTools = registerApiTools;
 const zod_1 = require("zod");
 const logger_js_1 = require("../logger.js");
+const executor_js_1 = require("../executor.js");
 const HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE"];
 const TIMEOUT = Number(process.env.ORY_HTTP_TIMEOUT) || 30_000;
 const MAX_RESPONSE_SIZE = 5 * 1024 * 1024; // 5 MB
-function resolveBaseUrl(explicit) {
-    return explicit ?? process.env.ORY_PROJECT_URL ?? process.env.ORY_SDK_URL ?? null;
+/**
+ * The project URL, resolved from the `ory` CLI's selected project.
+ *
+ * `ORY_PROJECT_URL` / `ORY_SDK_URL` are **security-half** values: a project only
+ * sets them to connect Ory Agent Security. `ory_api_request` is a DX-half tool,
+ * and every other tool in this server already works off nothing but the CLI's
+ * own session — so requiring a security-half value here made one DX tool fail
+ * on a DX-only install against a real project, before a credential was even
+ * considered (#216).
+ *
+ * Two calls, because the CLI splits the answer: `ory use project` yields the
+ * selected project's **id**, and the SDK URL is **slug**-based. A project id is
+ * a UUID and is never substituted into the URL — that would produce a hostname
+ * that does not resolve.
+ *
+ * Everything here is best-effort. A missing CLI, an expired session, no
+ * selected project, or output that does not parse all collapse to `null`, and
+ * the caller reports the same "no base URL" error it always did.
+ */
+async function resolveProjectUrlFromCli() {
+    const projectId = process.env.ORY_PROJECT?.trim() || (await selectedProjectId());
+    if (!projectId)
+        return null;
+    const project = await runOryJson(["get", "project", projectId, "--format", "json"]);
+    const slug = typeof project?.slug === "string" ? project.slug.trim() : "";
+    return slug ? `https://${slug}.projects.oryapis.com` : null;
+}
+async function selectedProjectId() {
+    const selected = await runOryJson(["use", "project", "--format", "json"]);
+    const id = typeof selected?.id === "string" ? selected.id.trim() : "";
+    // The CLI writes a zero UUID when nothing has been selected.
+    return id && !/^0{8}-0{4}-0{4}-0{4}-0{12}$/.test(id) ? id : null;
+}
+/**
+ * Run an `ory` command and parse its stdout as JSON, or `null`.
+ *
+ * The exit code is not sufficient on its own: `ory use project` with no
+ * selection prints `Error: no project was specified` and still exits 0. Parsing
+ * is therefore the test — anything that is not a JSON object is "no answer".
+ */
+async function runOryJson(args) {
+    try {
+        const result = await (0, executor_js_1.runOryCommand)(args);
+        if (result.exitCode !== 0)
+            return null;
+        const parsed = JSON.parse(result.stdout);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        // No CLI on PATH, a timeout, or non-JSON output. All mean "cannot answer".
+        return null;
+    }
+}
+/**
+ * Resolved project URL, cached for the life of the process.
+ *
+ * The lookup costs up to two subprocesses and `ory_api_request` is called
+ * repeatedly in a session, so a successful answer is cached. The in-flight
+ * promise is what is stored, so concurrent calls share one lookup.
+ *
+ * A **failure is deliberately not cached.** This server is long-lived — one
+ * stdio process per harness session — and the error it returns tells the user to
+ * run `ory use project`. Caching the failure would make that instruction false
+ * until they restarted the harness. The cost of re-trying is a couple of spawns
+ * on a path that is already returning an error, and a missing binary fails fast
+ * with ENOENT rather than waiting out the timeout.
+ */
+let cliProjectUrl;
+/** Drop the cached CLI lookup. For tests. */
+function resetProjectUrlCache() {
+    cliProjectUrl = undefined;
+}
+async function resolveBaseUrl(explicit) {
+    const fromEnv = explicit ?? process.env.ORY_PROJECT_URL ?? process.env.ORY_SDK_URL;
+    if (fromEnv)
+        return fromEnv;
+    const pending = (cliProjectUrl ??= resolveProjectUrlFromCli());
+    const resolved = await pending;
+    // Only a real answer sticks; see above.
+    if (resolved === null && cliProjectUrl === pending)
+        cliProjectUrl = undefined;
+    return resolved;
 }
 function resolveEnvApiKey() {
     return process.env.ORY_API_KEY ?? process.env.ORY_ACCESS_TOKEN;
@@ -67,13 +151,14 @@ function buildUrl(baseUrl, path, query) {
     return url.toString();
 }
 async function executeApiCall(params) {
-    const baseUrl = resolveBaseUrl(params.base_url);
+    const baseUrl = await resolveBaseUrl(params.base_url);
     if (!baseUrl) {
         return {
             content: [
                 {
                     type: "text",
-                    text: "No base URL is configured. Set the ORY_PROJECT_URL environment variable or pass 'base_url'.",
+                    text: "No base URL is configured. Select a project with 'ory use project <id>', " +
+                        "set the ORY_PROJECT_URL environment variable, or pass 'base_url'.",
                 },
             ],
             isError: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ory/mcp-server",
-  "version": "0.14.0",
+  "version": "1.0.1",
   "description": "MCP server exposing the Ory CLI and Ory Network REST API as tools for AI agents to manage identities, OAuth2 clients, permissions, projects, and configuration",
   "license": "Apache-2.0",
   "homepage": "https://ory.com",
@@ -56,7 +56,6 @@
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "reo-census": "^1.2.8",
     "zod": "^4.4.3"
   },
   "engines": {