Skip to content

The open-source agent harness - the runtime layer that turns an LLM into a working agent.

AGE-1668: add /me and auth middleare (#85)

Sujai Kumar Guptafeacff414779
diff --git a/fern/openapi/openapi.json b/fern/openapi/openapi.json
index 9215742fc..9cc8dccf3 100644
--- a/fern/openapi/openapi.json
+++ b/fern/openapi/openapi.json
@@ -1734,6 +1734,32 @@
],
"type": "string"
},
+ "MeResponse": {
+ "properties": {
+ "email": {
+ "description": "User email from the ID token when connected; `\"default\"` when anonymous.",
+ "type": "string"
+ },
+ "role": {
+ "description": "Caller role.",
+ "type": "string"
+ },
+ "type": {
+ "description": "Session kind: `default` when no valid OIDC session; `oidc-connected` after a successful browser login.",
+ "enum": [
+ "default",
+ "oidc-connected"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "type",
+ "email",
+ "role"
+ ],
+ "type": "object"
+ },
"Model": {
"additionalProperties": false,
"properties": {
@@ -4106,6 +4132,34 @@
"x-fern-sdk-method-name": "logout"
}
},
+ "/api/v1/auth/me": {
+ "get": {
+ "description": "Returns the authenticated caller identity. When OIDC is configured this requires a valid session cookie (401 otherwise). Without OIDC, returns the default anonymous identity.",
+ "responses": {
+ "200": {
+ "content": {
+ "application/json": {
+ "schema": {
+ "$ref": "#/components/schemas/MeResponse"
+ }
+ }
+ },
+ "description": "Session type and identity for the current request."
+ },
+ "401": {
+ "description": "OIDC is configured and the request has no valid session cookie."
+ }
+ },
+ "summary": "Current session",
+ "tags": [
+ "Auth"
+ ],
+ "x-fern-sdk-group-name": [
+ "auth"
+ ],
+ "x-fern-sdk-method-name": "me"
+ }
+ },
"/api/v1/capabilities": {
"get": {
"description": "Report optional runtime capabilities available for this tenant.",
@@ -5671,7 +5725,7 @@
}
}
},
- "description": "The MCP server requires authentication."
+ "description": "Harness session login required."
},
"404": {
"content": {
@@ -5683,6 +5737,16 @@
},
"description": "MCP server not found."
},
+ "422": {
+ "content": {
+ "application/json": {
+ "schema": {
+ "$ref": "#/components/schemas/RequestErrorResponse"
+ }
+ }
+ },
+ "description": "The MCP server requires authentication (does not trigger browser OIDC login)."
+ },
"502": {
"content": {
"application/json": {
diff --git a/packages/sdk/.fern/metadata.json b/packages/sdk/.fern/metadata.json
index d7d3ce2ae..4931b8405 100644
--- a/packages/sdk/.fern/metadata.json
+++ b/packages/sdk/.fern/metadata.json
@@ -27,7 +27,7 @@
"streamType": "web",
"useDefaultRequestParameterValues": true
},
- "originGitCommit": "38280abf13ab4acc6191e3b327785a0dc319086f",
+ "originGitCommit": "726b897b61e31bb94007a9f07937edb42ebc0135",
"originGitCommitIsDirty": true,
"invokedBy": "ci",
"requestedVersion": "0.0.0",
diff --git a/packages/sdk/pnpm-lock.yaml b/packages/sdk/pnpm-lock.yaml
index 60bd0dbd8..97a117338 100644
--- a/packages/sdk/pnpm-lock.yaml
+++ b/packages/sdk/pnpm-lock.yaml
@@ -405,8 +405,8 @@ packages:
resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==}
- resolution: {integrity: sha512-daRXJ9EB/rdRgu7kV+TTl1YUKtlsMWblPl2sLnpg9DZae16QCegol6A1SmCE31Lm9mXC1sRWGt/krouH+/dl7Q==}
+ resolution: {integrity: sha512-xxWVywk6a6Arlk+hymeycyn/VgqEfLDxupvhH/xiY5SJ/18kmi9o6MiO320DCUzypORHLtvh0I4i04tUhCNHNQ==}
resolution: {integrity: sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==}
@@ -1318,14 +1318,14 @@ snapshots:
dependencies:
baseline-browser-mapping: 2.11.12
- caniuse-lite: 1.0.30001807
+ caniuse-lite: 1.0.30001809
electron-to-chromium: 1.5.402
node-releases: 2.0.53
update-browserslist-db: 1.3.0([email protected])
diff --git a/packages/sdk/reference.md b/packages/sdk/reference.md
index d2c782486..d8dadddae 100644
--- a/packages/sdk/reference.md
+++ b/packages/sdk/reference.md
@@ -313,6 +313,61 @@ await client.auth.logout();
</dl>
+</dd>
+</dl>
+</details>
+
+<details><summary><code>client.auth.<a href="/src/api/resources/auth/client/Client.ts">me</a>() -> TrueForge.MeResponse</code></summary>
+<dl>
+<dd>
+
+#### πŸ“ Description
+
+<dl>
+<dd>
+
+<dl>
+<dd>
+
+Returns the authenticated caller identity. When OIDC is configured this requires a valid session cookie (401 otherwise). Without OIDC, returns the default anonymous identity.
+</dd>
+</dl>
+</dd>
+</dl>
+
+#### πŸ”Œ Usage
+
+<dl>
+<dd>
+
+<dl>
+<dd>
+
+```typescript
+await client.auth.me();
+
+```
+</dd>
+</dl>
+</dd>
+</dl>
+
+#### βš™οΈ Parameters
+
+<dl>
+<dd>
+
+<dl>
+<dd>
+
+**requestOptions:** `AuthClient.RequestOptions`
+
+</dd>
+</dl>
+</dd>
+</dl>
+
+
</dd>
</dl>
</details>
diff --git a/packages/sdk/src/api/errors/UnauthorizedError.ts b/packages/sdk/src/api/errors/UnauthorizedError.ts
index 6180fba73..e17ea94be 100644
--- a/packages/sdk/src/api/errors/UnauthorizedError.ts
+++ b/packages/sdk/src/api/errors/UnauthorizedError.ts
@@ -2,12 +2,9 @@
import type * as core from "../../core/index.js";
import * as errors from "../../errors/index.js";
-import type * as TrueForge from "../index.js";
export class UnauthorizedError extends errors.TrueForgeError {
- public declare readonly body: TrueForge.RequestErrorResponse;
-
- constructor(body: TrueForge.RequestErrorResponse, rawResponse?: core.RawResponse) {
+ constructor(body?: unknown, rawResponse?: core.RawResponse) {
super({
message: "UnauthorizedError",
statusCode: 401,
diff --git a/packages/sdk/src/api/resources/auth/client/Client.ts b/packages/sdk/src/api/resources/auth/client/Client.ts
index d1ba6a25c..9ac2b4478 100644
--- a/packages/sdk/src/api/resources/auth/client/Client.ts
+++ b/packages/sdk/src/api/resources/auth/client/Client.ts
@@ -6,6 +6,8 @@ import { mergeHeaders } from "../../../../core/headers.js";
import * as core from "../../../../core/index.js";
import { handleNonStatusCodeError } from "../../../../errors/handleNonStatusCodeError.js";
import * as errors from "../../../../errors/index.js";
+import * as serializers from "../../../../serialization/index.js";
+import * as TrueForge from "../../../index.js";
export declare namespace AuthClient {
export type Options = BaseClientOptions;
@@ -66,4 +68,68 @@ export class AuthClient {
return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/api/v1/auth/logout");
}
+
+ /**
+ * Returns the authenticated caller identity. When OIDC is configured this requires a valid session cookie (401 otherwise). Without OIDC, returns the default anonymous identity.
+ *
+ * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
+ *
+ * @throws {@link TrueForge.UnauthorizedError}
+ * @throws {@link errors.TrueForgeError}
+ * @throws {@link errors.TrueForgeTimeoutError}
+ *
+ * @example
+ * await client.auth.me()
+ */
+ public me(requestOptions?: AuthClient.RequestOptions): core.HttpResponsePromise<TrueForge.MeResponse> {
+ return core.HttpResponsePromise.fromPromise(this.__me(requestOptions));
+ }
+
+ private async __me(
+ requestOptions?: AuthClient.RequestOptions,
+ ): Promise<core.WithRawResponse<TrueForge.MeResponse>> {
+ const _headers: core.Fetcher.Args["headers"] = mergeHeaders(this._options?.headers, requestOptions?.headers);
+ const _response = await (this._options.fetcher ?? core.fetcher)({
+ url: core.url.join(
+ (await core.Supplier.get(this._options.baseUrl)) ??
+ (await core.Supplier.get(this._options.environment)),
+ "api/v1/auth/me",
+ ),
+ method: "GET",
+ headers: _headers,
+ queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+ timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+ maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+ abortSignal: requestOptions?.abortSignal,
+ fetchFn: this._options?.fetch,
+ logging: this._options.logging,
+ });
+ if (_response.ok) {
+ return {
+ data: serializers.MeResponse.parseOrThrow(_response.body, {
+ unrecognizedObjectKeys: "passthrough",
+ allowUnrecognizedUnionMembers: true,
+ allowUnrecognizedEnumValues: true,
+ skipValidation: true,
+ breadcrumbsPrefix: ["response"],
+ }),
+ rawResponse: _response.rawResponse,
+ };
+ }
+
+ if (_response.error.reason === "status-code") {
+ switch (_response.error.statusCode) {
+ case 401:
+ throw new TrueForge.UnauthorizedError(_response.error.body, _response.rawResponse);
+ default:
+ throw new errors.TrueForgeError({
+ statusCode: _response.error.statusCode,
+ body: _response.error.body,
+ rawResponse: _response.rawResponse,
+ });
+ }
+ }
+
+ return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/api/v1/auth/me");
+ }
}
diff --git a/packages/sdk/src/api/resources/settings/resources/mcpServers/client/Client.ts b/packages/sdk/src/api/resources/settings/resources/mcpServers/client/Client.ts
index 6c95e4fce..5fa830043 100644
--- a/packages/sdk/src/api/resources/settings/resources/mcpServers/client/Client.ts
+++ b/packages/sdk/src/api/resources/settings/resources/mcpServers/client/Client.ts
@@ -334,6 +334,7 @@ export class McpServersClient {
*
* @throws {@link TrueForge.UnauthorizedError}
* @throws {@link TrueForge.NotFoundError}
+ * @throws {@link TrueForge.UnprocessableEntityError}
* @throws {@link TrueForge.BadGatewayError}
* @throws {@link errors.TrueForgeError}
* @throws {@link errors.TrueForgeTimeoutError}
@@ -384,7 +385,9 @@ export class McpServersClient {
if (_response.error.reason === "status-code") {
switch (_response.error.statusCode) {
case 401:
- throw new TrueForge.UnauthorizedError(
+ throw new TrueForge.UnauthorizedError(_response.error.body, _response.rawResponse);
+ case 404:
+ throw new TrueForge.NotFoundError(
serializers.RequestErrorResponse.parseOrThrow(_response.error.body, {
unrecognizedObjectKeys: "passthrough",
allowUnrecognizedUnionMembers: true,
@@ -394,8 +397,8 @@ export class McpServersClient {
}),
_response.rawResponse,
);
- case 404:
- throw new TrueForge.NotFoundError(
+ case 422:
+ throw new TrueForge.UnprocessableEntityError(
serializers.RequestErrorResponse.parseOrThrow(_response.error.body, {
unrecognizedObjectKeys: "passthrough",
allowUnrecognizedUnionMembers: true,
diff --git a/packages/sdk/src/api/types/MeResponse.ts b/packages/sdk/src/api/types/MeResponse.ts
new file mode 100644
index 000000000..adb5cb33b
--- /dev/null
+++ b/packages/sdk/src/api/types/MeResponse.ts
@@ -0,0 +1,12 @@
+// This file was auto-generated by Fern from our API Definition.
+
+import type * as TrueForge from "../index.js";
+
+export interface MeResponse {
+ /** User email from the ID token when connected; `"default"` when anonymous. */
+ email: string;
+ /** Caller role. */
+ role: string;
+ /** Session kind: `default` when no valid OIDC session; `oidc-connected` after a successful browser login. */
+ type: TrueForge.MeResponseType;
+}
diff --git a/packages/sdk/src/api/types/MeResponseType.ts b/packages/sdk/src/api/types/MeResponseType.ts
new file mode 100644
index 000000000..171931a93
--- /dev/null
+++ b/packages/sdk/src/api/types/MeResponseType.ts
@@ -0,0 +1,8 @@
+// This file was auto-generated by Fern from our API Definition.
+
+/** Session kind: `default` when no valid OIDC session; `oidc-connected` after a successful browser login. */
+export const MeResponseType = {
+ Default: "default",
+ OidcConnected: "oidc-connected",
+} as const;
+export type MeResponseType = (typeof MeResponseType)[keyof typeof MeResponseType];
diff --git a/packages/sdk/src/api/types/index.ts b/packages/sdk/src/api/types/index.ts
index 3bbd6192c..8cb75afa1 100644
--- a/packages/sdk/src/api/types/index.ts
+++ b/packages/sdk/src/api/types/index.ts
@@ -86,6 +86,8 @@ export * from "./McpServerReadEntry.js";
export * from "./McpServerRequireApprovalForToolsItem.js";
export * from "./McpServerType.js";
export * from "./McpToolInfo.js";
+export * from "./MeResponse.js";
+export * from "./MeResponseType.js";
export * from "./Model.js";
export * from "./ModelEntry.js";
export * from "./ModelMessageDeltaEvent.js";
diff --git a/packages/sdk/src/serialization/types/MeResponse.ts b/packages/sdk/src/serialization/types/MeResponse.ts
new file mode 100644
index 000000000..dbc4d062f
--- /dev/null
+++ b/packages/sdk/src/serialization/types/MeResponse.ts
@@ -0,0 +1,21 @@
+// This file was auto-generated by Fern from our API Definition.
+
+import type * as TrueForge from "../../api/index.js";
+import * as core from "../../core/index.js";
+import type * as serializers from "../index.js";
+import { MeResponseType } from "./MeResponseType.js";
+
+export const MeResponse: core.serialization.ObjectSchema<serializers.MeResponse.Raw, TrueForge.MeResponse> =
+ core.serialization.object({
+ email: core.serialization.string(),
+ role: core.serialization.string(),
+ type: MeResponseType,
+ });
+
+export declare namespace MeResponse {
+ export interface Raw {
+ email: string;
+ role: string;
+ type: MeResponseType.Raw;
+ }
+}
diff --git a/packages/sdk/src/serialization/types/MeResponseType.ts b/packages/sdk/src/serialization/types/MeResponseType.ts
new file mode 100644
index 000000000..e788154ab
--- /dev/null
+++ b/packages/sdk/src/serialization/types/MeResponseType.ts
@@ -0,0 +1,12 @@
+// This file was auto-generated by Fern from our API Definition.
+
+import type * as TrueForge from "../../api/index.js";
+import * as core from "../../core/index.js";
+import type * as serializers from "../index.js";
+
+export const MeResponseType: core.serialization.Schema<serializers.MeResponseType.Raw, TrueForge.MeResponseType> =
+ core.serialization.enum_(["default", "oidc-connected"]);
+
+export declare namespace MeResponseType {
+ export type Raw = "default" | "oidc-connected";
+}
diff --git a/packages/sdk/src/serialization/types/index.ts b/packages/sdk/src/serialization/types/index.ts
index 3bbd6192c..8cb75afa1 100644
--- a/packages/sdk/src/serialization/types/index.ts
+++ b/packages/sdk/src/serialization/types/index.ts
@@ -86,6 +86,8 @@ export * from "./McpServerReadEntry.js";
export * from "./McpServerRequireApprovalForToolsItem.js";
export * from "./McpServerType.js";
export * from "./McpToolInfo.js";
+export * from "./MeResponse.js";
+export * from "./MeResponseType.js";
export * from "./Model.js";
export * from "./ModelEntry.js";
export * from "./ModelMessageDeltaEvent.js";
diff --git a/packages/sdk/tests/wire/auth.test.ts b/packages/sdk/tests/wire/auth.test.ts
index 064f26f16..1b873110d 100644
--- a/packages/sdk/tests/wire/auth.test.ts
+++ b/packages/sdk/tests/wire/auth.test.ts
@@ -1,5 +1,6 @@
// This file was auto-generated by Fern from our API Definition.
+import * as TrueForgeTypes from "../../src/api/index";
import { TrueForge } from "../../src/Client";
import { mockServerPool } from "../mock-server/MockServerPool";
@@ -13,4 +14,33 @@ describe("AuthClient", () => {
const response = await client.auth.logout();
expect(response).toEqual(undefined);
});
+
+ test("me (1)", async () => {
+ const server = mockServerPool.createServer();
+ const client = new TrueForge({ maxRetries: 0, baseUrl: server.baseUrl });
+
+ const rawResponseBody = { email: "email", role: "role", type: "default" };
+
+ server.mockEndpoint().get("/api/v1/auth/me").respondWith().statusCode(200).jsonBody(rawResponseBody).build();
+
+ const response = await client.auth.me();
+ expect(response).toEqual({
+ email: "email",
+ role: "role",
+ type: "default",
+ });
+ });
+
+ test("me (2)", async () => {
+ const server = mockServerPool.createServer();
+ const client = new TrueForge({ maxRetries: 0, baseUrl: server.baseUrl });
+
+ const rawResponseBody = { key: "value" };
+
+ server.mockEndpoint().get("/api/v1/auth/me").respondWith().statusCode(401).jsonBody(rawResponseBody).build();
+
+ await expect(async () => {
+ return await client.auth.me();
+ }).rejects.toThrow(TrueForgeTypes.UnauthorizedError);
+ });
});
diff --git a/packages/sdk/tests/wire/settings/mcpServers.test.ts b/packages/sdk/tests/wire/settings/mcpServers.test.ts
index d7ca55e34..85131b5f3 100644
--- a/packages/sdk/tests/wire/settings/mcpServers.test.ts
+++ b/packages/sdk/tests/wire/settings/mcpServers.test.ts
@@ -231,7 +231,7 @@ describe("McpServersClient", () => {
const server = mockServerPool.createServer();
const client = new TrueForge({ maxRetries: 0, baseUrl: server.baseUrl });
- const rawResponseBody = { error: { message: "message" } };
+ const rawResponseBody = { key: "value" };
server
.mockEndpoint()
@@ -271,6 +271,25 @@ describe("McpServersClient", () => {
const rawResponseBody = { error: { message: "message" } };
+ server
+ .mockEndpoint()
+ .get("/api/v1/settings/mcp-servers/name/tools")
+ .respondWith()
+ .statusCode(422)
+ .jsonBody(rawResponseBody)
+ .build();
+
+ await expect(async () => {
+ return await client.settings.mcpServers.listTools("name");
+ }).rejects.toThrow(TrueForgeTypes.UnprocessableEntityError);
+ });
+
+ test("list_tools (5)", async () => {
+ const server = mockServerPool.createServer();
+ const client = new TrueForge({ maxRetries: 0, baseUrl: server.baseUrl });
+
+ const rawResponseBody = { error: { message: "message" } };
+
server
.mockEndpoint()
.get("/api/v1/settings/mcp-servers/name/tools")
diff --git a/packages/server/package.json b/packages/server/package.json
index 7c5544752..6fe995e25 100644
--- a/packages/server/package.json
+++ b/packages/server/package.json
@@ -41,6 +41,7 @@
"better-sqlite3": "^13.0.2",
"env-paths": "^4.0.0",
"hono": "^4.12.34",
+ "jose": "^6.2.8",
"kysely": "^0.29.4",
"openid-client": "^6.8.4",
"pg": "^8.22.0",
@@ -58,7 +59,6 @@
"@types/node": "^24.12.0",
"@types/pg": "^8.20.0",
"jest": "^29.7.0",
- "jose": "^6.2.8",
"tsup": "^8.5.0",
"tsx": "^4.16.2",
"typescript": "^7.0.2"
diff --git a/packages/server/src/apis/auth.ts b/packages/server/src/apis/auth.ts
index b651db5ed..624bbde14 100644
--- a/packages/server/src/apis/auth.ts
+++ b/packages/server/src/apis/auth.ts
@@ -2,11 +2,17 @@ import { OpenAPIHono } from '@hono/zod-openapi';
import type { Configuration } from 'openid-client';
import type { Logger } from 'winston';
import { clearAuthCookie, ID_TOKEN_COOKIE, OAUTH_STATE_COOKIE, readOAuthStateCookie } from '../auth/cookies';
-import { buildLoginAuthorization, exchangeAuthorizationCode, safeReturnTo } from '../auth/oidc';
-import { authLoginRoute, authLogoutRoute, oAuthCallbackRoute } from '../routes/authRoutes';
+import { authMiddleware, DEFAULT_USER_CONTEXT } from '../auth/middleware';
+import { buildLoginAuthorization, exchangeAuthorizationCode, getOidcVerify, safeReturnTo } from '../auth/oidc';
+import { authLoginRoute, authLogoutRoute, meRoute, oAuthCallbackRoute } from '../routes/authRoutes';
+import type { MeResponse } from '../schemas/auth';
const LOGIN_ERROR_PATH = '/?error=login_failed';
+/**
+ * Auth surfaces mounted at /api/v1/auth: login, callback, logout, me.
+ * Login, callback, and logout stay public; me requires {@link authMiddleware}.
+ */
export function createAuthRouter(params: { oidcClient: Configuration | undefined; logger: Logger }) {
const router = new OpenAPIHono();
@@ -69,5 +75,16 @@ export function createAuthRouter(params: { oidcClient: Configuration | undefined
return c.body(null, 204);
});
+ const gated = new OpenAPIHono();
+ gated.use('*', authMiddleware);
+ gated.openapi(meRoute, c => {
+ const user = c.get('user') ?? DEFAULT_USER_CONTEXT;
+ const body: MeResponse = getOidcVerify()
+ ? { type: 'oidc-connected', email: user.userRef, role: user.role }
+ : { type: 'default', email: user.userRef, role: user.role };
+ return c.json(body, 200);
+ });
+ router.route('/', gated);
+
return router;
}
diff --git a/packages/server/src/apis/mcpServers.ts b/packages/server/src/apis/mcpServers.ts
index ac8e936dc..f842cbc7e 100644
--- a/packages/server/src/apis/mcpServers.ts
+++ b/packages/server/src/apis/mcpServers.ts
@@ -193,7 +193,7 @@ export function createSettingsMcpServersRouter(deps: SettingsMcpServersRouterDep
try {
const response = await remote.listTools();
if (isAuthRequired(response)) {
- return c.json({ error: { message: `MCP server "${name}" requires authentication` } }, 401);
+ return c.json({ error: { message: `MCP server "${name}" requires authentication` } }, 422);
}
const data = response.result.tools.map(tool => omitUndefinedEntries({ ...tool }));
return c.json({ data }, 200);
@@ -201,7 +201,7 @@ export function createSettingsMcpServersRouter(deps: SettingsMcpServersRouterDep
if (error instanceof McpConnectionError) {
deps.logger.warn(`MCP tools/list failed for "${name}"`, extractErrorLogFields(error));
if (error.statusCode === 401) {
- return c.json({ error: { message: error.message } }, 401);
+ return c.json({ error: { message: error.message } }, 422);
}
return c.json({ error: { message: error.message } }, 502);
}
diff --git a/packages/server/src/apis/settings.ts b/packages/server/src/apis/settings.ts
index 4399a16f6..db220f5d3 100644
--- a/packages/server/src/apis/settings.ts
+++ b/packages/server/src/apis/settings.ts
@@ -1,7 +1,7 @@
/**
* Admin/settings API surface under /api/v1/settings.
- * Sub-routers (model-providers, mcp-servers, skills, sandbox-providers) mount here so
- * a single policy can wrap the whole tree later without touching each resource.
+ * Sub-routers (model-providers, mcp-servers, skills, sandbox-providers) mount here.
+ * Auth is applied at the /api/v1/settings mount boundary in app.ts.
*/
import { OpenAPIHono } from '@hono/zod-openapi';
import type { Logger } from 'winston';
diff --git a/packages/server/src/app.ts b/packages/server/src/app.ts
index 2e68e5c88..c6fb602e0 100644
--- a/packages/server/src/app.ts
+++ b/packages/server/src/app.ts
@@ -18,6 +18,7 @@ import { createSessionsRouter } from './apis/sessions';
import { createSettingsRouter } from './apis/settings';
import { createAvailableSkillsRouter } from './apis/skills';
import { createTurnsRouter } from './apis/turns';
+import { authMiddleware } from './auth/middleware';
import type { McpCatalog } from './catalog/McpCatalog';
import type { ModelCatalog } from './catalog/ModelCatalog';
import type { SandboxCatalog } from './catalog/SandboxCatalog';
@@ -50,6 +51,14 @@ function routeNotFound(c: Context) {
return c.json({ error: { message: `Route not found: ${c.req.method} ${c.req.path}` } }, 404);
}
+/** Sub-app shell: `.use('*', authMiddleware)` then child routes β€” same as gateway routers. */
+function withAuth(router: OpenAPIHono): OpenAPIHono {
+ const shell = new OpenAPIHono();
+ shell.use('*', authMiddleware);
+ shell.route('/', router);
+ return shell;
+}
+
export interface ServerDeps {
modelCatalog: ModelCatalog;
mcpCatalog: McpCatalog;
@@ -81,17 +90,13 @@ export function createServerApp(deps: ServerDeps) {
app.get('/healthz', c => c.text('OK!'));
app.route('/api/v1/auth', createAuthRouter({ oidcClient: deps.oidcClient, logger: deps.logger }));
- app.route('/api/v1/capabilities', createCapabilitiesRouter({ sandboxProviderStore: deps.sandboxProviderStore }));
- app.route('/api/v1/models', createModelsRouter(deps.modelProviderStore));
app.route(
- '/api/v1/mcp-servers',
- createMcpServersRouter({
- mcpServerStore: deps.mcpServerStore,
- tokenStore: deps.tokenStore,
- logger: deps.logger,
- }),
+ '/api/v1/capabilities',
+ withAuth(createCapabilitiesRouter({ sandboxProviderStore: deps.sandboxProviderStore })),
);
- // Shared OAuth callback β€” path must match the server-owned MCP_OAUTH_CALLBACK_PATH.
+ app.route('/api/v1/models', withAuth(createModelsRouter(deps.modelProviderStore)));
+ // Public MCP OAuth callback must be registered before the gated `/mcp-servers` mount so
+ // `withAuth` cannot intercept IdP redirects to `/api/v1/mcp-servers/oauth/*`.
app.route(
'/api/v1/mcp-servers/oauth',
createMcpOAuthRouter({
@@ -100,62 +105,80 @@ export function createServerApp(deps: ServerDeps) {
logger: deps.logger,
}),
);
- app.route('/api/v1/skills', createAvailableSkillsRouter(deps.skillStore));
+ app.route(
+ '/api/v1/mcp-servers',
+ withAuth(
+ createMcpServersRouter({
+ mcpServerStore: deps.mcpServerStore,
+ tokenStore: deps.tokenStore,
+ logger: deps.logger,
+ }),
+ ),
+ );
+ app.route('/api/v1/skills', withAuth(createAvailableSkillsRouter(deps.skillStore)));
app.route(
'/api/v1/agents',
- createAgentsRouter({
- agentStore: deps.agentStore,
- modelProviderStore: deps.modelProviderStore,
- mcpServerStore: deps.mcpServerStore,
- skillStore: deps.skillStore,
- sandboxProviderStore: deps.sandboxProviderStore,
- }),
+ withAuth(
+ createAgentsRouter({
+ agentStore: deps.agentStore,
+ modelProviderStore: deps.modelProviderStore,
+ mcpServerStore: deps.mcpServerStore,
+ skillStore: deps.skillStore,
+ sandboxProviderStore: deps.sandboxProviderStore,
+ }),
+ ),
);
app.route(
'/api/v1/settings',
- createSettingsRouter({
- modelCatalog: deps.modelCatalog,
- modelProviderStore: deps.modelProviderStore,
- mcpCatalog: deps.mcpCatalog,
- mcpServerStore: deps.mcpServerStore,
- tokenStore: deps.tokenStore,
- skillCatalog: deps.skillCatalog,
- skillStore: deps.skillStore,
- sandboxCatalog: deps.sandboxCatalog,
- sandboxProviderStore: deps.sandboxProviderStore,
- logger: deps.logger,
- }),
+ withAuth(
+ createSettingsRouter({
+ modelCatalog: deps.modelCatalog,
+ modelProviderStore: deps.modelProviderStore,
+ mcpCatalog: deps.mcpCatalog,
+ mcpServerStore: deps.mcpServerStore,
+ tokenStore: deps.tokenStore,
+ skillCatalog: deps.skillCatalog,
+ skillStore: deps.skillStore,
+ sandboxCatalog: deps.sandboxCatalog,
+ sandboxProviderStore: deps.sandboxProviderStore,
+ logger: deps.logger,
+ }),
+ ),
);
app.route(
'/api/v1/sessions',
- createSessionsRouter({
- sessions: deps.sessions,
- sessionStore: deps.sessionStore,
- activeTurns: deps.activeTurns,
- modelProviderStore: deps.modelProviderStore,
- mcpServerStore: deps.mcpServerStore,
- skillStore: deps.skillStore,
- agentStore: deps.agentStore,
- sandboxProviderStore: deps.sandboxProviderStore,
- redis: deps.redis,
- requestReplyRouter: deps.requestReplyRouter,
- }),
+ withAuth(
+ createSessionsRouter({
+ sessions: deps.sessions,
+ sessionStore: deps.sessionStore,
+ activeTurns: deps.activeTurns,
+ modelProviderStore: deps.modelProviderStore,
+ mcpServerStore: deps.mcpServerStore,
+ skillStore: deps.skillStore,
+ agentStore: deps.agentStore,
+ sandboxProviderStore: deps.sandboxProviderStore,
+ redis: deps.redis,
+ requestReplyRouter: deps.requestReplyRouter,
+ }),
+ ),
);
app.route(
'/api/v1/sessions',
- createTurnsRouter({
- sessions: deps.sessions,
- sessionStore: deps.sessionStore,
- activeTurns: deps.activeTurns,
- modelProviderStore: deps.modelProviderStore,
- mcpServerStore: deps.mcpServerStore,
- tokenStore: deps.tokenStore,
- skillStore: deps.skillStore,
- agentStore: deps.agentStore,
- eventSubscriptions: deps.eventSubscriptions,
- sandboxProviderStore: deps.sandboxProviderStore,
- logger: deps.logger,
- }),
+ withAuth(
+ createTurnsRouter({
+ sessions: deps.sessions,
+ sessionStore: deps.sessionStore,
+ activeTurns: deps.activeTurns,
+ modelProviderStore: deps.modelProviderStore,
+ mcpServerStore: deps.mcpServerStore,
+ tokenStore: deps.tokenStore,
+ skillStore: deps.skillStore,
+ agentStore: deps.agentStore,
+ eventSubscriptions: deps.eventSubscriptions,
+ sandboxProviderStore: deps.sandboxProviderStore,
+ logger: deps.logger,
+ }),
+ ),
);
app.get('/api/v1/docs', swaggerUI({ url: '/api/v1/openapi.json' }));
diff --git a/packages/server/src/auth/middleware.ts b/packages/server/src/auth/middleware.ts
new file mode 100644
index 000000000..a9bfaecac
--- /dev/null
+++ b/packages/server/src/auth/middleware.ts
@@ -0,0 +1,71 @@
+import type { Context, MiddlewareHandler } from 'hono';
+import { getCookie } from 'hono/cookie';
+import { HTTPException } from 'hono/http-exception';
+import { jwtVerify } from 'jose';
+import { toUserContext, type IdTokenClaims, type UserContext } from './claims';
+import { ID_TOKEN_COOKIE } from './cookies';
+import { getOidcVerify } from './oidc';
+
+/** Used when OIDC is not configured (standalone / no IdP). */
+export const DEFAULT_USER_CONTEXT: UserContext = {
+ userRef: 'default',
+ role: 'user',
+};
+
+declare module 'hono' {
+ interface ContextVariableMap {
+ user?: UserContext;
+ }
+}
+
+/**
+ * Cookie β†’ {@link UserContext} when OIDC is on and the token is valid.
+ * Missing/invalid JWT β†’ `undefined`. Claim mapping failures after a successful verify rethrow.
+ */
+export async function resolveAuthUser(c: Context): Promise<UserContext | undefined> {
+ const oidcVerify = getOidcVerify();
+ if (!oidcVerify) {
+ return undefined;
+ }
+
+ const token = getCookie(c, ID_TOKEN_COOKIE);
+ if (!token) {
+ return undefined;
+ }
+
+ let payload: Awaited<ReturnType<typeof jwtVerify>>['payload'];
+ try {
+ ({ payload } = await jwtVerify(token, oidcVerify.jwks, {
+ issuer: oidcVerify.issuer,
+ audience: oidcVerify.audience,
+ }));
+ } catch {
+ return undefined;
+ }
+
+ const claims: IdTokenClaims = { ...payload };
+ return toUserContext(claims, oidcVerify.oidcConfig);
+}
+
+/** Set `c.var.user` and continue, or throw 401. Without OIDC, sets {@link DEFAULT_USER_CONTEXT}. */
+export const authMiddleware: MiddlewareHandler = async (c, next) => {
+ if (!getOidcVerify()) {
+ c.set('user', DEFAULT_USER_CONTEXT);
+ return next();
+ }
+
+ try {
+ const user = await resolveAuthUser(c);
+ if (!user) {
+ throw new HTTPException(401, { message: 'Authentication required' });
+ }
+ c.set('user', user);
+ } catch (error) {
+ if (error instanceof HTTPException) {
+ throw error;
+ }
+ // Valid JWT but claim mapping failed (e.g. missing user reference claim).
+ throw new HTTPException(401, { message: 'Authentication required', cause: error });
+ }
+ return next();
+};
diff --git a/packages/server/src/auth/oidc.ts b/packages/server/src/auth/oidc.ts
index 75961c5dc..c4b9db29e 100644
--- a/packages/server/src/auth/oidc.ts
+++ b/packages/server/src/auth/oidc.ts
@@ -1,4 +1,5 @@
import type { Context } from 'hono';
+import { createRemoteJWKSet, type JWTVerifyGetKey } from 'jose';
import {
authorizationCodeGrant,
buildAuthorizationUrl,
@@ -17,13 +18,51 @@ const ID_TOKEN_COOKIE_MAX_AGE_SECONDS = 24 * 60 * 60;
// TODO: use dynamic claims/scopes when we add RBAC
const OIDC_SCOPES = 'openid email profile';
-/** Discover the IdP once at process startup when OIDC is configured. */
+/** JWKS + claim config used by cookie JWT verification when browser OIDC is on. */
+export interface OidcVerify {
+ jwks: JWTVerifyGetKey;
+ issuer: string;
+ audience: string;
+ oidcConfig: OIDCConfig;
+}
+
+let oidcVerify: OidcVerify | null = null;
+
+/** Enable cookie JWT verification using the IdP client + claim-mapping config from `initOidc`. */
+export function enableOidcAuth(params: { client: Configuration; oidcConfig: OIDCConfig }): void {
+ const metadata = params.client.serverMetadata();
+ if (!metadata.jwks_uri) {
+ throw new Error('OIDC discovery did not return jwks_uri; cannot verify ID tokens');
+ }
+
+ oidcVerify = {
+ jwks: createRemoteJWKSet(new URL(metadata.jwks_uri)),
+ issuer: metadata.issuer,
+ audience: params.client.clientMetadata().client_id,
+ oidcConfig: params.oidcConfig,
+ };
+}
+
+/** Disable OIDC cookie auth (no IdP / standalone). Protected routes use the default user context. */
+export function disableOidcAuth(): void {
+ oidcVerify = null;
+}
+
+/** Active verification config, or `null` when OIDC browser auth is off. */
+export function getOidcVerify(): OidcVerify | null {
+ return oidcVerify;
+}
+
+/** Discover the IdP once at process startup when OIDC is configured; wires cookie auth verification. */
export async function initOidc(oidc: OIDCConfig | undefined): Promise<Configuration | undefined> {
if (!oidc) {
+ disableOidcAuth();
return undefined;
}
- return discovery(new URL(oidc.OIDC_ISSUER_URL), oidc.OIDC_CLIENT_ID, oidc.OIDC_CLIENT_SECRET);
+ const client = await discovery(new URL(oidc.OIDC_ISSUER_URL), oidc.OIDC_CLIENT_ID, oidc.OIDC_CLIENT_SECRET);
+ enableOidcAuth({ client, oidcConfig: oidc });
+ return client;
}
function authCallbackUrl(): string {
diff --git a/packages/server/src/routes/authRoutes.ts b/packages/server/src/routes/authRoutes.ts
index d237ef9ce..b53523360 100644
--- a/packages/server/src/routes/authRoutes.ts
+++ b/packages/server/src/routes/authRoutes.ts
@@ -3,10 +3,10 @@
*
* `login`/`callback` are browser-redirect targets, never called by SDK
* consumers β€” both carry `x-fern-ignore`, the same convention used for the
- * MCP OAuth callback in mcpOAuthRoutes.ts. `logout` generates normally.
+ * MCP OAuth callback in mcpOAuthRoutes.ts. `logout` and `me` generate normally.
*/
import { createRoute } from '@hono/zod-openapi';
-import { AuthLoginQuerySchema, OAuthCallbackQuerySchema } from '../schemas/auth';
+import { AuthLoginQuerySchema, MeResponseSchema, OAuthCallbackQuerySchema } from '../schemas/auth';
const AUTH_TAG = 'Auth';
@@ -54,3 +54,22 @@ export const authLogoutRoute = createRoute({
204: { description: 'Session cookie cleared.' },
},
});
+
+export const meRoute = createRoute({
+ method: 'get',
+ path: '/me',
+ tags: [AUTH_TAG],
+ summary: 'Current session',
+ description:
+ 'Returns the authenticated caller identity. When OIDC is configured this requires a valid session cookie ' +
+ '(401 otherwise). Without OIDC, returns the default anonymous identity.',
+ 'x-fern-sdk-group-name': ['auth'],
+ 'x-fern-sdk-method-name': 'me',
+ responses: {
+ 200: {
+ content: { 'application/json': { schema: MeResponseSchema } },
+ description: 'Session type and identity for the current request.',
+ },
+ 401: { description: 'OIDC is configured and the request has no valid session cookie.' },
+ },
+});
diff --git a/packages/server/src/routes/mcpServerRoutes.ts b/packages/server/src/routes/mcpServerRoutes.ts
index 8a81bf57d..ca4e9554f 100644
--- a/packages/server/src/routes/mcpServerRoutes.ts
+++ b/packages/server/src/routes/mcpServerRoutes.ts
@@ -149,12 +149,16 @@ export const listMcpServerToolsRoute = createRoute({
},
401: {
content: { 'application/json': { schema: RequestErrorResponseSchema } },
- description: 'The MCP server requires authentication.',
+ description: 'Harness session login required.',
},
404: {
content: { 'application/json': { schema: RequestErrorResponseSchema } },
description: 'MCP server not found.',
},
+ 422: {
+ content: { 'application/json': { schema: RequestErrorResponseSchema } },
+ description: 'The MCP server requires authentication (does not trigger browser OIDC login).',
+ },
502: {
content: { 'application/json': { schema: RequestErrorResponseSchema } },
description: 'The MCP server could not be reached or returned an error.',
diff --git a/packages/server/src/schemas/auth.ts b/packages/server/src/schemas/auth.ts
index 94b903ca2..647db1baa 100644
--- a/packages/server/src/schemas/auth.ts
+++ b/packages/server/src/schemas/auth.ts
@@ -24,3 +24,17 @@ export const OAuthCallbackQuerySchema = z.object({
export const OAuthCallbackSuccessSchema = z.object({
success: z.literal(true),
});
+
+export const MeResponseSchema = z
+ .object({
+ type: z
+ .enum(['default', 'oidc-connected'])
+ .describe(
+ 'Session kind: `default` when no valid OIDC session; `oidc-connected` after a successful browser login.',
+ ),
+ email: z.string().describe('User email from the ID token when connected; `"default"` when anonymous.'),
+ role: z.string().describe('Caller role.'),
+ })
+ .openapi('MeResponse');
+
+export type MeResponse = z.infer<typeof MeResponseSchema>;
diff --git a/packages/server/tests/unit/apis/auth.test.ts b/packages/server/tests/unit/apis/auth.test.ts
index 171703736..a8cbe6fce 100644
--- a/packages/server/tests/unit/apis/auth.test.ts
+++ b/packages/server/tests/unit/apis/auth.test.ts
@@ -3,7 +3,7 @@ import { createHash } from 'node:crypto';
import type { Configuration } from 'openid-client';
import winston from 'winston';
import { createAuthRouter } from '../../../src/apis/auth';
-import { initOidc } from '../../../src/auth/oidc';
+import { disableOidcAuth, initOidc } from '../../../src/auth/oidc';
import configuration from '../../../src/config';
jest.mock('../../../src/config', () => {
@@ -40,7 +40,11 @@ const logger = winston.createLogger({ silent: true });
const ACCESS_TOKEN = 'access-1';
describe('auth router (no identity provider configured)', () => {
- it('GET /login redirects home β€” there is nothing to log into', async () => {
+ beforeEach(() => {
+ disableOidcAuth();
+ });
+
+ it('GET /auth/login redirects home β€” there is nothing to log into', async () => {
const router = createAuthRouter({ oidcClient: undefined, logger });
const res = await router.request('/login', { redirect: 'manual' });
@@ -49,7 +53,7 @@ describe('auth router (no identity provider configured)', () => {
expect(res.headers.get('location')).toBe('/');
});
- it('GET /callback redirects home β€” there is nothing to complete', async () => {
+ it('GET /auth/callback redirects home β€” there is nothing to complete', async () => {
const router = createAuthRouter({ oidcClient: undefined, logger });
const res = await router.request('/callback?state=abc', { redirect: 'manual' });
@@ -58,13 +62,22 @@ describe('auth router (no identity provider configured)', () => {
expect(res.headers.get('location')).toBe('/');
});
- it('POST /logout is a no-op 204 β€” there is no real session to clear', async () => {
+ it('POST /auth/logout is a no-op 204 β€” there is no real session to clear', async () => {
const router = createAuthRouter({ oidcClient: undefined, logger });
const res = await router.request('/logout', { method: 'POST' });
expect(res.status).toBe(204);
});
+
+ it('GET /auth/me returns the default identity when OIDC is off', async () => {
+ const router = createAuthRouter({ oidcClient: undefined, logger });
+
+ const res = await router.request('/me');
+
+ expect(res.status).toBe(200);
+ expect(await res.json()).toEqual({ type: 'default', email: 'default', role: 'user' });
+ });
});
function json(body: unknown, status = 200): Response {
@@ -214,4 +227,18 @@ describe('auth router (OIDC configured)', () => {
setCookies(res).some(cookie => cookie.startsWith(`${ID_TOKEN_COOKIE}=`) && cookie.includes('Max-Age=0')),
).toBe(true);
});
+
+ it('GET /me returns 401 when the id_token cookie is missing', async () => {
+ const res = await createAuthRouter({ oidcClient, logger }).request('/me');
+ expect(res.status).toBe(401);
+ });
+
+ it('GET /me returns oidc-connected identity when authenticated', async () => {
+ const token = await createIdToken();
+ const res = await createAuthRouter({ oidcClient, logger }).request('/me', {
+ headers: { Cookie: `${ID_TOKEN_COOKIE}=${token}` },
+ });
+ expect(res.status).toBe(200);
+ expect(await res.json()).toEqual({ type: 'oidc-connected', email: 'user-1', role: 'user' });
+ });
});
diff --git a/packages/server/tests/unit/auth/middleware.test.ts b/packages/server/tests/unit/auth/middleware.test.ts
new file mode 100644
index 000000000..0a3a3917f
--- /dev/null
+++ b/packages/server/tests/unit/auth/middleware.test.ts
@@ -0,0 +1,193 @@
+import { OpenAPIHono } from '@hono/zod-openapi';
+import { HTTPException } from 'hono/http-exception';
+import { exportJWK, generateKeyPair, SignJWT } from 'jose';
+import type { Configuration } from 'openid-client';
+import { authMiddleware } from '../../../src/auth/middleware';
+import { disableOidcAuth, enableOidcAuth, initOidc } from '../../../src/auth/oidc';
+import type { OIDCConfig } from '../../../src/config';
+
+const ISSUER = 'https://issuer.example.com';
+const AUDIENCE = 'harness-client';
+
+const OIDC_CONFIG: OIDCConfig = {
+ OIDC_ISSUER_URL: `${ISSUER}/`,
+ OIDC_CLIENT_ID: AUDIENCE,
+ OIDC_CLIENT_SECRET: 'harness-secret',
+ OIDC_USER_REFERENCE_CLAIM: 'sub',
+ OIDC_USER_ROLE_CLAIM: 'groups',
+ OIDC_ADMIN_ROLE_VALUE: 'admin',
+};
+
+function json(body: unknown, status = 200): Response {
+ return new Response(JSON.stringify(body), {
+ status,
+ headers: { 'Content-Type': 'application/json' },
+ });
+}
+
+function createApp() {
+ const app = new OpenAPIHono();
+ app.onError((error, c) => {
+ if (error instanceof HTTPException) {
+ return c.json({ error: { message: error.message } }, error.status);
+ }
+ throw error;
+ });
+
+ // Public mounts β€” no auth middleware (mirrors production allowlist shape).
+ app.get('/healthz', c => c.json({ public: true }));
+ app.get('/api/v1/auth/login', c => c.json({ public: true }));
+ app.get('/api/v1/auth/callback', c => c.json({ public: true }));
+ app.get('/api/v1/mcp-servers/oauth/callback', c => c.json({ public: true }));
+ app.get('/api/v1/openapi', c => c.json({ public: true }));
+
+ const models = new OpenAPIHono();
+ models.use('*', authMiddleware);
+ models.get('/', c => c.json({ ok: true, user: c.get('user') }));
+ app.route('/api/v1/models', models);
+
+ return app;
+}
+
+describe('authMiddleware', () => {
+ it('sets default user when OIDC is not configured', async () => {
+ disableOidcAuth();
+ const res = await createApp().request('/api/v1/models');
+ expect(res.status).toBe(200);
+ expect(await res.json()).toEqual({
+ ok: true,
+ user: { userRef: 'default', role: 'user' },
+ });
+ });
+
+ describe('when OIDC is configured', () => {
+ const realFetch = globalThis.fetch;
+ let privateKey: Awaited<ReturnType<typeof generateKeyPair>>['privateKey'];
+ let oidcClient: Configuration;
+
+ beforeAll(async () => {
+ const keyPair = await generateKeyPair('RS256');
+ privateKey = keyPair.privateKey;
+ const publicJwk = await exportJWK(keyPair.publicKey);
+ publicJwk.kid = 'test-kid';
+ publicJwk.alg = 'RS256';
+ publicJwk.use = 'sig';
+
+ globalThis.fetch = async input => {
+ const url = String(input);
+ if (url === `${ISSUER}/.well-known/openid-configuration`) {
+ return json({
+ issuer: ISSUER,
+ authorization_endpoint: `${ISSUER}/authorize`,
+ token_endpoint: `${ISSUER}/token`,
+ jwks_uri: `${ISSUER}/jwks`,
+ response_types_supported: ['code'],
+ id_token_signing_alg_values_supported: ['RS256'],
+ subject_types_supported: ['public'],
+ });
+ }
+ if (url === `${ISSUER}/jwks`) {
+ return json({ keys: [publicJwk] });
+ }
+ return new Response(`unexpected url: ${url}`, { status: 404 });
+ };
+
+ const client = await initOidc(OIDC_CONFIG);
+ if (!client) {
+ throw new Error('OIDC client was not initialized');
+ }
+ oidcClient = client;
+ });
+
+ afterAll(() => {
+ globalThis.fetch = realFetch;
+ disableOidcAuth();
+ });
+
+ beforeEach(() => {
+ enableOidcAuth({ client: oidcClient, oidcConfig: OIDC_CONFIG });
+ });
+
+ async function createIdToken(params?: {
+ issuer?: string;
+ audience?: string;
+ sub?: string;
+ groups?: string[];
+ exp?: string | number;
+ }): Promise<string> {
+ return new SignJWT({ groups: params?.groups ?? [] })
+ .setProtectedHeader({ alg: 'RS256', kid: 'test-kid' })
+ .setIssuer(params?.issuer ?? ISSUER)
+ .setAudience(params?.audience ?? AUDIENCE)
+ .setSubject(params?.sub ?? 'user-1')
+ .setIssuedAt()
+ .setExpirationTime(params?.exp ?? '1h')
+ .sign(privateKey);
+ }
+
+ it('returns 401 when the id_token cookie is missing', async () => {
+ const res = await createApp().request('/api/v1/models');
+ expect(res.status).toBe(401);
+ expect(await res.json()).toEqual({ error: { message: 'Authentication required' } });
+ });
+
+ it('returns 401 when the token is invalid', async () => {
+ const res = await createApp().request('/api/v1/models', {
+ headers: { Cookie: 'id_token=not-a-jwt' },
+ });
+ expect(res.status).toBe(401);
+ expect(await res.json()).toEqual({ error: { message: 'Authentication required' } });
+ });
+
+ it('returns 401 when the token has the wrong issuer', async () => {
+ const token = await createIdToken({ issuer: 'https://other.example.com' });
+ const res = await createApp().request('/api/v1/models', {
+ headers: { Cookie: `id_token=${token}` },
+ });
+ expect(res.status).toBe(401);
+ expect(await res.json()).toEqual({ error: { message: 'Authentication required' } });
+ });
+
+ it('returns 401 when the token has the wrong audience', async () => {
+ const token = await createIdToken({ audience: 'other-client' });
+ const res = await createApp().request('/api/v1/models', {
+ headers: { Cookie: `id_token=${token}` },
+ });
+ expect(res.status).toBe(401);
+ expect(await res.json()).toEqual({ error: { message: 'Authentication required' } });
+ });
+
+ it('returns 401 when the token is expired', async () => {
+ const token = await createIdToken({ exp: Math.floor(Date.now() / 1000) - 60 });
+ const res = await createApp().request('/api/v1/models', {
+ headers: { Cookie: `id_token=${token}` },
+ });
+ expect(res.status).toBe(401);
+ expect(await res.json()).toEqual({ error: { message: 'Authentication required' } });
+ });
+
+ it('sets user context from claims (reference claim + role)', async () => {
+ const token = await createIdToken({ sub: 'alice', groups: ['admin'] });
+ const res = await createApp().request('/api/v1/models', {
+ headers: { Cookie: `id_token=${token}` },
+ });
+ expect(res.status).toBe(200);
+ expect(await res.json()).toEqual({
+ ok: true,
+ user: { userRef: 'alice', role: 'admin' },
+ });
+ });
+
+ it.each([
+ '/healthz',
+ '/api/v1/auth/login',
+ '/api/v1/auth/callback',
+ '/api/v1/mcp-servers/oauth/callback',
+ '/api/v1/openapi',
+ ])('does not gate public mount %s', async path => {
+ const res = await createApp().request(path);
+ expect(res.status).toBe(200);
+ expect(await res.json()).toEqual({ public: true });
+ });
+ });
+});
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 68c871d89..857f502d3 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -227,6 +227,9 @@ importers:
hono:
specifier: ^4.12.34
version: 4.13.0
+ jose:
+ specifier: ^6.2.8
+ version: 6.2.8
kysely:
specifier: ^0.29.4
version: 0.29.4
@@ -273,9 +276,6 @@ importers:
jest:
specifier: ^29.7.0
- jose:
- specifier: ^6.2.8
- version: 6.2.8
tsup:
specifier: ^8.5.0