Skip to content

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

make MCP auth per user (#145)

Heer Ambavi6f533fd031ab
diff --git a/.github/fern/openapi/openapi.json b/.github/fern/openapi/openapi.json
index 4948d4399..45659354d 100644
--- a/.github/fern/openapi/openapi.json
+++ b/.github/fern/openapi/openapi.json
@@ -1696,6 +1696,7 @@
},
"McpAuthStatus": {
"additionalProperties": false,
+ "description": "Auth state for the calling user.",
"properties": {
"authorization_url": {
"description": "When auth is required, this contains the URL to redirect the user to for authorization.",
@@ -1717,6 +1718,41 @@
],
"type": "object"
},
+ "McpServerAuthPublic": {
+ "description": "Auth mechanism when configured (no secrets). Omit when the server needs no credentials.",
+ "oneOf": [
+ {
+ "additionalProperties": false,
+ "properties": {
+ "type": {
+ "enum": [
+ "dcr"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "type"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "type": {
+ "enum": [
+ "header"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "type"
+ ],
+ "type": "object"
+ }
+ ]
+ },
"McpServerDcrAuth": {
"additionalProperties": false,
"properties": {
@@ -1786,6 +1822,12 @@
"McpServerReadEntry": {
"additionalProperties": false,
"properties": {
+ "auth": {
+ "$ref": "#/components/schemas/McpServerAuthPublic"
+ },
+ "auth_status": {
+ "$ref": "#/components/schemas/McpAuthStatus"
+ },
"name": {
"$ref": "#/components/schemas/ResourceName"
},
@@ -1797,7 +1839,8 @@
},
"required": [
"name",
- "url"
+ "url",
+ "auth_status"
],
"type": "object"
},
diff --git a/packages/frontend/README.md b/packages/frontend/README.md
index 908d65a77..d27b82342 100644
--- a/packages/frontend/README.md
+++ b/packages/frontend/README.md
@@ -69,7 +69,7 @@ callbacks; `App.tsx` spreads them into `createTrueFoundryServer` (settings CRUD
| Callback | Source |
| -------------- | ----------------------------------------------------------------- |
| `getModels` | `GET /api/v1/models` (also seeds `defaultAgentSpec.model`) |
-| `getMcp` | `GET /api/v1/settings/mcp-servers` (carries auth status) |
+| `getMcp` | `GET /api/v1/mcp-servers` (name/url + per-user auth_status) |
| `getSkills` | `GET /api/v1/skills` when `GET /api/v1/capabilities` has skill on |
| `searchAgents` | `GET /api/v1/agents`, filtered by `query` and paged client-side |
| `saveAgent` | `PUT`/`POST /api/v1/agents` — updates by name, else creates |
diff --git a/packages/frontend/src/composerLists.ts b/packages/frontend/src/composerLists.ts
index 16fac431f..5837f855b 100644
--- a/packages/frontend/src/composerLists.ts
+++ b/packages/frontend/src/composerLists.ts
@@ -9,8 +9,8 @@ export async function listModels(): Promise<TrueForgeApi.Model[]> {
const body = await client.models.list();
return body.data;
}
-export async function listConfiguredMcpServers(): Promise<TrueForgeApi.ConfiguredMcpServer[]> {
- const body = await client.settings.mcpServers.list();
+export async function listConfiguredMcpServers(): Promise<TrueForgeApi.McpServerReadEntry[]> {
+ const body = await client.mcpServers.list();
return body.data;
}
diff --git a/packages/frontend/src/connectorCatalog.ts b/packages/frontend/src/connectorCatalog.ts
index 1d0c83344..b92914443 100644
--- a/packages/frontend/src/connectorCatalog.ts
+++ b/packages/frontend/src/connectorCatalog.ts
@@ -84,6 +84,18 @@ export function toUiConnector(server: TrueForgeApi.ConfiguredMcpServer): UiConne
};
}
+export function toUiConnectorFromReadEntry(server: TrueForgeApi.McpServerReadEntry): UiConnector {
+ return {
+ id: server.name,
+ name: server.name,
+ description: server.url,
+ url: server.url,
+ auth: { type: 'none' },
+ requiresAuth: server.authStatus.status === 'auth_required',
+ authenticated: server.authStatus.status !== 'auth_required',
+ };
+}
+
export interface HarnessMcpUpsert {
name: string;
url: string;
diff --git a/packages/frontend/src/harnessBuilderServer.ts b/packages/frontend/src/harnessBuilderServer.ts
index 81f3710a7..f7fde2020 100644
--- a/packages/frontend/src/harnessBuilderServer.ts
+++ b/packages/frontend/src/harnessBuilderServer.ts
@@ -10,7 +10,7 @@ import type {
} from '@truefoundry/trueforge-ui';
import type { TrueForgeApi } from 'trueforge-sdk';
import { listConfiguredMcpServers, listModels, listSkills } from './composerLists';
-import { toUiConnector } from './connectorCatalog';
+import { toUiConnectorFromReadEntry } from './connectorCatalog';
import { createHarnessClient, harnessClient, type CreateHarnessClientOptions } from './harnessClient';
import { agentManifest, toHarnessAgentSpec, toUiAgentSpec, type HarnessAgentSpec } from './harnessServer';
@@ -51,7 +51,7 @@ export function createHarnessBuilderServer(
const skills = await listSkills();
return skills.map(skill => ({ id: skill.name, name: skill.name, description: skill.description }));
},
- getMcp: async () => (await listConfiguredMcpServers()).map(toUiConnector),
+ getMcp: async () => (await listConfiguredMcpServers()).map(toUiConnectorFromReadEntry),
async searchAgents(req?: SearchAgentsParams) {
const { data } = await client.agents.list();
diff --git a/packages/frontend/tests/connectorCatalog.test.ts b/packages/frontend/tests/connectorCatalog.test.ts
index 9fb83d75c..b5a95b611 100644
--- a/packages/frontend/tests/connectorCatalog.test.ts
+++ b/packages/frontend/tests/connectorCatalog.test.ts
@@ -6,6 +6,7 @@ import {
toUiAuthPublic,
toUiCatalogEntry,
toUiConnector,
+ toUiConnectorFromReadEntry,
toUiTool,
} from '../src/connectorCatalog';
@@ -95,6 +96,25 @@ describe('connectorCatalog mappers', () => {
assert.equal(connected.requiresAuth, false);
});
+ it('maps chat read entries from per-user auth_status', () => {
+ assert.deepEqual(
+ toUiConnectorFromReadEntry({
+ name: 'linear',
+ url: 'https://mcp.linear.app/mcp',
+ authStatus: { status: 'auth_required' },
+ }),
+ {
+ id: 'linear',
+ name: 'linear',
+ description: 'https://mcp.linear.app/mcp',
+ url: 'https://mcp.linear.app/mcp',
+ auth: { type: 'none' },
+ requiresAuth: true,
+ authenticated: false,
+ },
+ );
+ });
+
it('maps tool rows with description for getToolsByConnectorId', () => {
assert.deepEqual(toUiTool({ name: 'search', description: 'Find docs' }), {
id: 'search',
diff --git a/packages/sdk/.fern/metadata.json b/packages/sdk/.fern/metadata.json
index e715f9984..3b9073251 100644
--- a/packages/sdk/.fern/metadata.json
+++ b/packages/sdk/.fern/metadata.json
@@ -28,7 +28,7 @@
"streamType": "web",
"useDefaultRequestParameterValues": true
},
- "originGitCommit": "af97db7768c8ccbd876506483e5e3074a7475728",
+ "originGitCommit": "a8d2e1b8839a98ec2ab7b243964412484747cad2",
"originGitCommitIsDirty": true,
"invokedBy": "ci",
"requestedVersion": "0.0.0",
diff --git a/packages/sdk/src/api/types/McpAuthStatus.ts b/packages/sdk/src/api/types/McpAuthStatus.ts
index 2dd0f93e8..6aea9c4ed 100644
--- a/packages/sdk/src/api/types/McpAuthStatus.ts
+++ b/packages/sdk/src/api/types/McpAuthStatus.ts
@@ -2,6 +2,9 @@
import type * as TrueForge from "../index.js";
+/**
+ * Auth state for the calling user.
+ */
export interface McpAuthStatus {
/** When auth is required, this contains the URL to redirect the user to for authorization. */
authorizationUrl?: string;
diff --git a/packages/sdk/src/api/types/McpServerAuthPublic.ts b/packages/sdk/src/api/types/McpServerAuthPublic.ts
new file mode 100644
index 000000000..e68c79f4a
--- /dev/null
+++ b/packages/sdk/src/api/types/McpServerAuthPublic.ts
@@ -0,0 +1,8 @@
+// This file was auto-generated by Fern from our API Definition.
+
+import type * as TrueForge from "../index.js";
+
+/**
+ * Auth mechanism when configured (no secrets). Omit when the server needs no credentials.
+ */
+export type McpServerAuthPublic = TrueForge.McpServerAuthPublicZero | TrueForge.McpServerAuthPublicOne;
diff --git a/packages/sdk/src/api/types/McpServerAuthPublicOne.ts b/packages/sdk/src/api/types/McpServerAuthPublicOne.ts
new file mode 100644
index 000000000..fb334586c
--- /dev/null
+++ b/packages/sdk/src/api/types/McpServerAuthPublicOne.ts
@@ -0,0 +1,5 @@
+// This file was auto-generated by Fern from our API Definition.
+
+export interface McpServerAuthPublicOne {
+ type: "header";
+}
diff --git a/packages/sdk/src/api/types/McpServerAuthPublicZero.ts b/packages/sdk/src/api/types/McpServerAuthPublicZero.ts
new file mode 100644
index 000000000..aff9e952b
--- /dev/null
+++ b/packages/sdk/src/api/types/McpServerAuthPublicZero.ts
@@ -0,0 +1,5 @@
+// This file was auto-generated by Fern from our API Definition.
+
+export interface McpServerAuthPublicZero {
+ type: "dcr";
+}
diff --git a/packages/sdk/src/api/types/McpServerReadEntry.ts b/packages/sdk/src/api/types/McpServerReadEntry.ts
index d6b1f3f6a..0342b0b6e 100644
--- a/packages/sdk/src/api/types/McpServerReadEntry.ts
+++ b/packages/sdk/src/api/types/McpServerReadEntry.ts
@@ -3,6 +3,8 @@
import type * as TrueForge from "../index.js";
export interface McpServerReadEntry {
+ auth?: TrueForge.McpServerAuthPublic;
+ authStatus: TrueForge.McpAuthStatus;
name: TrueForge.ResourceName;
/** URL of the remote MCP server. */
url: string;
diff --git a/packages/sdk/src/api/types/index.ts b/packages/sdk/src/api/types/index.ts
index d80565b2e..248a80668 100644
--- a/packages/sdk/src/api/types/index.ts
+++ b/packages/sdk/src/api/types/index.ts
@@ -77,6 +77,9 @@ export * from "./McpAuthStatusStatus.js";
export * from "./McpInitializeEvent.js";
export * from "./McpServer.js";
export * from "./McpServerAuthInfo.js";
+export * from "./McpServerAuthPublic.js";
+export * from "./McpServerAuthPublicOne.js";
+export * from "./McpServerAuthPublicZero.js";
export * from "./McpServerDcrAuth.js";
export * from "./McpServerDisableToolsItem.js";
export * from "./McpServerEnableToolsItem.js";
diff --git a/packages/sdk/src/serialization/types/McpServerAuthPublic.ts b/packages/sdk/src/serialization/types/McpServerAuthPublic.ts
new file mode 100644
index 000000000..8013c5e95
--- /dev/null
+++ b/packages/sdk/src/serialization/types/McpServerAuthPublic.ts
@@ -0,0 +1,16 @@
+// 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 { McpServerAuthPublicOne } from "./McpServerAuthPublicOne.js";
+import { McpServerAuthPublicZero } from "./McpServerAuthPublicZero.js";
+
+export const McpServerAuthPublic: core.serialization.Schema<
+ serializers.McpServerAuthPublic.Raw,
+ TrueForge.McpServerAuthPublic
+> = core.serialization.undiscriminatedUnion([McpServerAuthPublicZero, McpServerAuthPublicOne]);
+
+export declare namespace McpServerAuthPublic {
+ export type Raw = McpServerAuthPublicZero.Raw | McpServerAuthPublicOne.Raw;
+}
diff --git a/packages/sdk/src/serialization/types/McpServerAuthPublicOne.ts b/packages/sdk/src/serialization/types/McpServerAuthPublicOne.ts
new file mode 100644
index 000000000..ddf84addb
--- /dev/null
+++ b/packages/sdk/src/serialization/types/McpServerAuthPublicOne.ts
@@ -0,0 +1,18 @@
+// 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 McpServerAuthPublicOne: core.serialization.ObjectSchema<
+ serializers.McpServerAuthPublicOne.Raw,
+ TrueForge.McpServerAuthPublicOne
+> = core.serialization.object({
+ type: core.serialization.stringLiteral("header"),
+});
+
+export declare namespace McpServerAuthPublicOne {
+ export interface Raw {
+ type: "header";
+ }
+}
diff --git a/packages/sdk/src/serialization/types/McpServerAuthPublicZero.ts b/packages/sdk/src/serialization/types/McpServerAuthPublicZero.ts
new file mode 100644
index 000000000..3e312c64e
--- /dev/null
+++ b/packages/sdk/src/serialization/types/McpServerAuthPublicZero.ts
@@ -0,0 +1,18 @@
+// 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 McpServerAuthPublicZero: core.serialization.ObjectSchema<
+ serializers.McpServerAuthPublicZero.Raw,
+ TrueForge.McpServerAuthPublicZero
+> = core.serialization.object({
+ type: core.serialization.stringLiteral("dcr"),
+});
+
+export declare namespace McpServerAuthPublicZero {
+ export interface Raw {
+ type: "dcr";
+ }
+}
diff --git a/packages/sdk/src/serialization/types/McpServerReadEntry.ts b/packages/sdk/src/serialization/types/McpServerReadEntry.ts
index 4e4db7533..a5e2d7c6f 100644
--- a/packages/sdk/src/serialization/types/McpServerReadEntry.ts
+++ b/packages/sdk/src/serialization/types/McpServerReadEntry.ts
@@ -3,18 +3,24 @@
import type * as TrueForge from "../../api/index.js";
import * as core from "../../core/index.js";
import type * as serializers from "../index.js";
+import { McpAuthStatus } from "./McpAuthStatus.js";
+import { McpServerAuthPublic } from "./McpServerAuthPublic.js";
import { ResourceName } from "./ResourceName.js";
export const McpServerReadEntry: core.serialization.ObjectSchema<
serializers.McpServerReadEntry.Raw,
TrueForge.McpServerReadEntry
> = core.serialization.object({
+ auth: McpServerAuthPublic.optional(),
+ authStatus: core.serialization.property("auth_status", McpAuthStatus),
name: ResourceName,
url: core.serialization.string(),
});
export declare namespace McpServerReadEntry {
export interface Raw {
+ auth?: McpServerAuthPublic.Raw | null;
+ auth_status: McpAuthStatus.Raw;
name: ResourceName.Raw;
url: string;
}
diff --git a/packages/sdk/src/serialization/types/index.ts b/packages/sdk/src/serialization/types/index.ts
index d80565b2e..248a80668 100644
--- a/packages/sdk/src/serialization/types/index.ts
+++ b/packages/sdk/src/serialization/types/index.ts
@@ -77,6 +77,9 @@ export * from "./McpAuthStatusStatus.js";
export * from "./McpInitializeEvent.js";
export * from "./McpServer.js";
export * from "./McpServerAuthInfo.js";
+export * from "./McpServerAuthPublic.js";
+export * from "./McpServerAuthPublicOne.js";
+export * from "./McpServerAuthPublicZero.js";
export * from "./McpServerDcrAuth.js";
export * from "./McpServerDisableToolsItem.js";
export * from "./McpServerEnableToolsItem.js";
diff --git a/packages/sdk/tests/wire/mcpServers.test.ts b/packages/sdk/tests/wire/mcpServers.test.ts
index 0af93e36d..99a4957b1 100644
--- a/packages/sdk/tests/wire/mcpServers.test.ts
+++ b/packages/sdk/tests/wire/mcpServers.test.ts
@@ -9,7 +9,9 @@ describe("McpServersClient", () => {
const server = mockServerPool.createServer();
const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
- const rawResponseBody = { data: [{ name: "name", url: "url" }] };
+ const rawResponseBody = {
+ data: [{ auth: { type: "dcr" }, auth_status: { status: "authenticated" }, name: "name", url: "url" }],
+ };
server
.mockEndpoint()
@@ -23,6 +25,12 @@ describe("McpServersClient", () => {
expect(response).toEqual({
data: [
{
+ auth: {
+ type: "dcr",
+ },
+ authStatus: {
+ status: "authenticated",
+ },
name: "name",
url: "url",
},
diff --git a/packages/server/src/apis/mcpServers.ts b/packages/server/src/apis/mcpServers.ts
index b7e78a45a..12a4073df 100644
--- a/packages/server/src/apis/mcpServers.ts
+++ b/packages/server/src/apis/mcpServers.ts
@@ -8,6 +8,7 @@ import {
withTimeout,
} from '@truefoundry/utils-core/core';
import type { Logger } from 'winston';
+import type { ResolveUserContext } from '../auth/identity';
import type { McpCatalog } from '../catalog/McpCatalog';
import configuration from '../config';
import type { IMcpServerStore, McpServerRecord } from '../db/mcpServerStore';
@@ -26,7 +27,7 @@ import {
putMcpServerRoute,
} from '../routes/mcpServerRoutes';
import { getMcpConnection } from '../runtime/sessionResources';
-import type { ConfiguredMcpServer, McpAuthStatus, McpServerManifest } from '../schemas/mcpServer';
+import type { ConfiguredMcpServer, McpAuthStatus, McpServerManifest, McpServerReadEntry } from '../schemas/mcpServer';
import { resolveMcpAuthStatus } from '../schemas/mcpServer';
import { TENANT_ID } from './sessions';
@@ -39,6 +40,7 @@ export interface SettingsMcpServersRouterDeps<TTransaction> {
tokenStore: IOAuthTokenStore<TTransaction>;
withTransaction: WithTransaction<TTransaction>;
logger: Logger;
+ resolveUserContext: ResolveUserContext;
}
export interface McpServersRouterDeps<TTransaction> {
@@ -46,6 +48,7 @@ export interface McpServersRouterDeps<TTransaction> {
tokenStore: IOAuthTokenStore<TTransaction>;
withTransaction: WithTransaction<TTransaction>;
logger: Logger;
+ resolveUserContext: ResolveUserContext;
}
/** Omits keys whose value is `undefined` so wire objects satisfy JSONValue index signatures. */
@@ -60,24 +63,41 @@ function omitUndefinedEntries(obj: Record<string, unknown>): Record<string, unkn
}
/**
- * `token` is the DCR access token stored for this server (keyed by `record.id`), or undefined for
- * header/no-auth servers and DCR servers that have never authorized. Only DCR reads it.
+ * `token` is the calling user's DCR access token for this server (keyed by `record.id` +
+ * `userRef`), or undefined for header/no-auth servers and DCR servers that have never
+ * authorized for this user. Only DCR reads it.
*/
function toConfiguredMcpServer({
record,
token,
- nowMs = Date.now(),
}: {
record: McpServerRecord;
token: OAuthToken | undefined;
- nowMs?: number;
}): ConfiguredMcpServer {
return {
...record.manifest,
auth_status: resolveMcpAuthStatus({
manifest: record.manifest,
...(token !== undefined ? { token } : {}),
- nowMs,
+ }),
+ };
+}
+
+function toMcpServerReadEntry({
+ record,
+ token,
+}: {
+ record: McpServerRecord;
+ token: OAuthToken | undefined;
+}): McpServerReadEntry {
+ const authType = record.manifest.auth?.type;
+ return {
+ name: record.name,
+ url: record.manifest.url,
+ ...(authType !== undefined ? { auth: { type: authType } } : {}),
+ auth_status: resolveMcpAuthStatus({
+ manifest: record.manifest,
+ ...(token !== undefined ? { token } : {}),
}),
};
}
@@ -109,31 +129,33 @@ export function createSettingsMcpServersRouter<TTransaction>(deps: SettingsMcpSe
};
const listHandler: RouteHandler<typeof listMcpServersRoute> = async c => {
+ const userRef = deps.resolveUserContext(c).userRef;
const records = await deps.mcpServerStore.listServers({ tenant_id: TENANT_ID, names: undefined });
- const nowMs = Date.now();
- // Only DCR servers have tokens; batch the lookup.
+ // Only DCR servers have tokens; batch the lookup for this user.
const dcrIds = records.filter(record => record.manifest.auth?.type === 'dcr').map(record => record.id);
- const tokens = await deps.tokenStore.getTokens({ ids: dcrIds });
+ const tokens = await deps.tokenStore.getTokens({ ids: dcrIds, userRef });
return c.json(
- { data: records.map(record => toConfiguredMcpServer({ record, token: tokens.get(record.id), nowMs })) },
+ { data: records.map(record => toConfiguredMcpServer({ record, token: tokens.get(record.id) })) },
200,
);
};
const getHandler: RouteHandler<typeof getMcpServerRoute> = async c => {
const { name } = c.req.valid('param');
+ const userRef = deps.resolveUserContext(c).userRef;
const record = await deps.mcpServerStore.getServer({ tenant_id: TENANT_ID, name });
if (!record) {
return c.json({ error: { message: `MCP server not found: ${name}` } }, 404);
}
let token: OAuthToken | undefined;
if (record.manifest.auth?.type === 'dcr') {
- token = await deps.tokenStore.getToken({ id: record.id });
+ token = await deps.tokenStore.getToken({ id: record.id, userRef });
}
return c.json({ data: toConfiguredMcpServer({ record, token }) }, 200);
};
const putHandler: RouteHandler<typeof putMcpServerRoute> = async c => {
+ const userRef = deps.resolveUserContext(c).userRef;
const manifest: McpServerManifest = c.req.valid('json');
const record = await deps.mcpServerStore.upsertServer({
tenant_id: TENANT_ID,
@@ -166,12 +188,14 @@ export function createSettingsMcpServersRouter<TTransaction>(deps: SettingsMcpSe
}
}
// A re-upsert preserves `id`, so a DCR server may already carry a token from a prior authorize.
- const token = record.manifest.auth?.type === 'dcr' ? await deps.tokenStore.getToken({ id: record.id }) : undefined;
+ const token =
+ record.manifest.auth?.type === 'dcr' ? await deps.tokenStore.getToken({ id: record.id, userRef }) : undefined;
return c.json({ data: toConfiguredMcpServer({ record, token }) }, 200);
};
const listToolsHandler: RouteHandler<typeof listMcpServerToolsRoute> = async c => {
const { name } = c.req.valid('param');
+ const userRef = deps.resolveUserContext(c).userRef;
// Same url + header resolution as turn execution (DCR via resolveMcpAuth, header/no-auth static).
const connection = await getMcpConnection({
tenant_id: TENANT_ID,
@@ -179,6 +203,7 @@ export function createSettingsMcpServersRouter<TTransaction>(deps: SettingsMcpSe
store: deps.mcpServerStore,
tokenStore: deps.tokenStore,
clientName: configuration.MCP_DCR_OAUTH_CLIENT_NAME,
+ userRef,
});
if (connection === undefined) {
return c.json({ error: { message: `MCP server not found: ${name}` } }, 404);
@@ -228,6 +253,7 @@ export function createMcpServersRouter<TTransaction>(deps: McpServersRouterDeps<
const authorizeHandler: RouteHandler<typeof authorizeMcpServerRoute> = async c => {
const { name } = c.req.valid('param');
const { redirect_url: redirectUrl } = c.req.valid('query');
+ const userRef = deps.resolveUserContext(c).userRef;
const record = await deps.mcpServerStore.getServer({ tenant_id: TENANT_ID, name });
if (!record) {
return c.json({ error: { message: `MCP server not found: ${name}` } }, 404);
@@ -246,6 +272,7 @@ export function createMcpServersRouter<TTransaction>(deps: McpServersRouterDeps<
tokenStore: deps.tokenStore,
mcpServerStore: deps.mcpServerStore,
serverId: record.id,
+ userRef,
mcpServerUrl: record.manifest.url,
mcpServerName: record.name,
clientName: configuration.MCP_DCR_OAUTH_CLIENT_NAME,
@@ -276,24 +303,28 @@ export function createMcpServersRouter<TTransaction>(deps: McpServersRouterDeps<
const deleteAuthHandler: RouteHandler<typeof deleteMcpServerAuthRoute> = async c => {
const { name } = c.req.valid('param');
+ const userRef = deps.resolveUserContext(c).userRef;
const record = await deps.mcpServerStore.getServer({ tenant_id: TENANT_ID, name });
if (!record) {
return c.json({ error: { message: `MCP server not found: ${name}` } }, 404);
}
- // DCR: drop the user token only — keep oauth_server / oauth_client so re-authorize can skip DCR.
+ // DCR: drop this user's token only — keep oauth_server / oauth_client so re-authorize can skip DCR.
// Header / no-auth: no-op.
if (record.manifest.auth?.type === 'dcr') {
- await deps.tokenStore.deleteToken({ id: record.id });
+ await deps.tokenStore.deleteToken({ id: record.id, userRef });
}
return c.json({ data: toConfiguredMcpServer({ record, token: undefined }) }, 200);
};
const router = new OpenAPIHono();
router.openapi(listAvailableMcpServersRoute, async c => {
+ const userRef = deps.resolveUserContext(c).userRef;
const records = await deps.mcpServerStore.listServers({ tenant_id: TENANT_ID, names: undefined });
+ const dcrIds = records.filter(record => record.manifest.auth?.type === 'dcr').map(record => record.id);
+ const tokens = await deps.tokenStore.getTokens({ ids: dcrIds, userRef });
return c.json(
{
- data: records.map(record => ({ name: record.name, url: record.manifest.url })),
+ data: records.map(record => toMcpServerReadEntry({ record, token: tokens.get(record.id) })),
},
200,
);
diff --git a/packages/server/src/apis/settings.ts b/packages/server/src/apis/settings.ts
index 940df5e7a..0b3f76b5a 100644
--- a/packages/server/src/apis/settings.ts
+++ b/packages/server/src/apis/settings.ts
@@ -5,6 +5,7 @@
*/
import { OpenAPIHono } from '@hono/zod-openapi';
import type { Logger } from 'winston';
+import type { ResolveUserContext } from '../auth/identity';
import type { McpCatalog } from '../catalog/McpCatalog';
import type { ModelCatalog } from '../catalog/ModelCatalog';
import type { SandboxCatalog } from '../catalog/SandboxCatalog';
@@ -32,6 +33,7 @@ export interface SettingsRouterDeps<TTransaction> {
sandboxProviderStore: ISandboxProviderStore<TTransaction>;
withTransaction: WithTransaction<TTransaction>;
logger: Logger;
+ resolveUserContext: ResolveUserContext;
}
export function createSettingsRouter<TTransaction>(deps: SettingsRouterDeps<TTransaction>) {
@@ -52,6 +54,7 @@ export function createSettingsRouter<TTransaction>(deps: SettingsRouterDeps<TTra
tokenStore: deps.tokenStore,
withTransaction: deps.withTransaction,
logger: deps.logger,
+ resolveUserContext: deps.resolveUserContext,
}),
);
router.route(
diff --git a/packages/server/src/apis/turns.ts b/packages/server/src/apis/turns.ts
index 0bbf2aa1f..6716cbeda 100644
--- a/packages/server/src/apis/turns.ts
+++ b/packages/server/src/apis/turns.ts
@@ -126,6 +126,7 @@ function createTurnResolver(deps: {
modelProviderStore: IModelProviderStore;
logger: Logger;
signal: AbortSignal;
+ userRef: string;
}): TurnResourceResolver {
const {
mcpServerStore,
@@ -136,6 +137,7 @@ function createTurnResolver(deps: {
modelProviderStore,
logger,
signal,
+ userRef,
} = deps;
return new TurnResourceResolver({
llm: async name => {
@@ -157,6 +159,7 @@ function createTurnResolver(deps: {
store: mcpServerStore,
tokenStore,
clientName: configuration.MCP_DCR_OAUTH_CLIENT_NAME,
+ userRef,
});
if (connection === undefined) {
throw new HTTPException(422, {
@@ -486,6 +489,7 @@ export function createTurnsRouter(deps: TurnsRouterDeps) {
modelProviderStore: deps.modelProviderStore,
logger: deps.logger,
signal: abortController.signal,
+ userRef: deps.resolveUserContext(c).userRef,
});
// First turn only: derive the title from the first user message. The store
diff --git a/packages/server/src/app.ts b/packages/server/src/app.ts
index bf0092244..18506f7e0 100644
--- a/packages/server/src/app.ts
+++ b/packages/server/src/app.ts
@@ -170,6 +170,7 @@ export function createServerApp<TTransaction>(deps: ServerDeps<TTransaction>) {
tokenStore: deps.tokenStore,
withTransaction: deps.withTransaction,
logger: deps.logger,
+ resolveUserContext,
}),
),
);
@@ -210,6 +211,7 @@ export function createServerApp<TTransaction>(deps: ServerDeps<TTransaction>) {
sandboxProviderStore: deps.sandboxProviderStore,
withTransaction: deps.withTransaction,
logger: deps.logger,
+ resolveUserContext,
}),
),
);
diff --git a/packages/server/src/db/mcpServerStore.ts b/packages/server/src/db/mcpServerStore.ts
index 5f0e5ed9e..ba5315bfd 100644
--- a/packages/server/src/db/mcpServerStore.ts
+++ b/packages/server/src/db/mcpServerStore.ts
@@ -145,7 +145,7 @@ export function fromStoredOAuthClientRecord(params: {
};
}
-/** The blob half of a pending authorization; `state`/`id` live in their own columns. */
+/** The blob half of a pending authorization; `state`/`id`/`user_id` live in their own columns. */
export function toStoredOAuthPendingAuthorizationData(
pending: ContractOAuthPendingAuthorization,
): OAuthPendingAuthorizationData {
diff --git a/packages/server/src/db/postgres/migrations/20260813_000001_mcp_oauth_user_scoped.ts b/packages/server/src/db/postgres/migrations/20260813_000001_mcp_oauth_user_scoped.ts
new file mode 100644
index 000000000..794562d4d
--- /dev/null
+++ b/packages/server/src/db/postgres/migrations/20260813_000001_mcp_oauth_user_scoped.ts
@@ -0,0 +1,44 @@
+import { sql, type Kysely } from 'kysely';
+
+/**
+ * Scope MCP OAuth access/refresh tokens per harness user, and stamp `user_id` on
+ * pending authorizations so the public callback can write the correct token row.
+ * Drops previously shared (server-only) tokens — callers must re-authorize.
+ *
+ * ACCESS EXCLUSIVE before each delete blocks concurrent inserts through the
+ * rest of this migration transaction.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+ await sql`SET LOCAL lock_timeout = '5s'`.execute(db);
+
+ await sql`LOCK TABLE oauth_token IN ACCESS EXCLUSIVE MODE`.execute(db);
+ await sql`DELETE FROM oauth_token`.execute(db);
+ await db.schema
+ .alterTable('oauth_token')
+ .addColumn('user_id', 'text', col => col.notNull())
+ .execute();
+ await sql`ALTER TABLE oauth_token DROP CONSTRAINT oauth_token_pkey`.execute(db);
+ await sql`ALTER TABLE oauth_token ADD CONSTRAINT oauth_token_pkey PRIMARY KEY (oauth_server_id, user_id)`.execute(db);
+
+ // In-flight pending rows cannot be attributed to a user; drop them.
+ await sql`LOCK TABLE oauth_pending_authorization IN ACCESS EXCLUSIVE MODE`.execute(db);
+ await sql`DELETE FROM oauth_pending_authorization`.execute(db);
+ await db.schema
+ .alterTable('oauth_pending_authorization')
+ .addColumn('user_id', 'text', col => col.notNull())
+ .execute();
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+ await sql`SET LOCAL lock_timeout = '5s'`.execute(db);
+
+ await sql`LOCK TABLE oauth_pending_authorization IN ACCESS EXCLUSIVE MODE`.execute(db);
+ await sql`DELETE FROM oauth_pending_authorization`.execute(db);
+ await db.schema.alterTable('oauth_pending_authorization').dropColumn('user_id').execute();
+
+ await sql`LOCK TABLE oauth_token IN ACCESS EXCLUSIVE MODE`.execute(db);
+ await sql`DELETE FROM oauth_token`.execute(db);
+ await sql`ALTER TABLE oauth_token DROP CONSTRAINT oauth_token_pkey`.execute(db);
+ await db.schema.alterTable('oauth_token').dropColumn('user_id').execute();
+ await sql`ALTER TABLE oauth_token ADD CONSTRAINT oauth_token_pkey PRIMARY KEY (oauth_server_id)`.execute(db);
+}
diff --git a/packages/server/src/db/postgres/token-store/PostgresOAuthTokenStore.ts b/packages/server/src/db/postgres/token-store/PostgresOAuthTokenStore.ts
index 9ac3eeff4..ec83c8169 100644
--- a/packages/server/src/db/postgres/token-store/PostgresOAuthTokenStore.ts
+++ b/packages/server/src/db/postgres/token-store/PostgresOAuthTokenStore.ts
@@ -1,5 +1,5 @@
import type { Kysely, Transaction } from 'kysely';
-import type { IOAuthTokenStore, OAuthPendingAuthorization, OAuthToken } from '../../../mcp/auth/types';
+import type { IOAuthTokenStore, OAuthPendingAuthorization, OAuthToken, OAuthTokenKey } from '../../../mcp/auth/types';
import { fromStoredOAuthToken, toStoredOAuthToken } from '../../mcpServerStore';
import type { Database } from '../types';
import { consumePendingAuthorization, savePendingAuthorization } from './queries/pendingAuthorization';
@@ -19,21 +19,28 @@ export class PostgresOAuthTokenStore implements IOAuthTokenStore<Transaction<Dat
return consumePendingAuthorization(transaction ?? this.db, params);
}
- saveToken(params: { id: string; token: OAuthToken }, transaction?: Transaction<Database>): Promise<void> {
- return saveToken(transaction ?? this.db, { id: params.id, token: toStoredOAuthToken(params.token) });
+ saveToken(params: OAuthTokenKey & { token: OAuthToken }, transaction?: Transaction<Database>): Promise<void> {
+ return saveToken(transaction ?? this.db, {
+ id: params.id,
+ userRef: params.userRef,
+ token: toStoredOAuthToken(params.token),
+ });
}
- async getToken(params: { id: string }, transaction?: Transaction<Database>): Promise<OAuthToken | undefined> {
+ async getToken(params: OAuthTokenKey, transaction?: Transaction<Database>): Promise<OAuthToken | undefined> {
const stored = await getToken(transaction ?? this.db, params);
return stored === undefined ? undefined : fromStoredOAuthToken(stored);
}
- async getTokens(params: { ids: string[] }, transaction?: Transaction<Database>): Promise<Map<string, OAuthToken>> {
+ async getTokens(
+ params: { ids: string[]; userRef: string },
+ transaction?: Transaction<Database>,
+ ): Promise<Map<string, OAuthToken>> {
const stored = await getTokens(transaction ?? this.db, params);
return new Map([...stored].map(([id, token]) => [id, fromStoredOAuthToken(token)]));
}
- deleteToken(params: { id: string }, transaction?: Transaction<Database>): Promise<void> {
+ deleteToken(params: OAuthTokenKey, transaction?: Transaction<Database>): Promise<void> {
return deleteToken(transaction ?? this.db, params);
}
}
diff --git a/packages/server/src/db/postgres/token-store/queries/pendingAuthorization.ts b/packages/server/src/db/postgres/token-store/queries/pendingAuthorization.ts
index f0616745a..b59fdd6fc 100644
--- a/packages/server/src/db/postgres/token-store/queries/pendingAuthorization.ts
+++ b/packages/server/src/db/postgres/token-store/queries/pendingAuthorization.ts
@@ -12,7 +12,6 @@ export async function savePendingAuthorization(
db: Kysely<Database>,
pending: OAuthPendingAuthorization,
): Promise<void> {
- // `state` and `id` are their own columns; only the remainder goes in the blob.
const authData = toStoredOAuthPendingAuthorizationData(pending);
await db
@@ -20,6 +19,7 @@ export async function savePendingAuthorization(
.values({
id: pending.state,
oauth_server_id: pending.id,
+ user_id: pending.userRef,
auth_data: json(authData),
created_at: now(),
})
@@ -38,7 +38,7 @@ export async function consumePendingAuthorization(
.deleteFrom('oauth_pending_authorization')
.where('id', '=', params.state)
.where('created_at', '>', nowMinusMs(PENDING_AUTHORIZATION_TTL_MS))
- .returning(['id', 'oauth_server_id', 'auth_data'])
+ .returning(['id', 'oauth_server_id', 'user_id', 'auth_data'])
.executeTakeFirst();
if (row === undefined) {
@@ -48,6 +48,7 @@ export async function consumePendingAuthorization(
return {
state: row.id,
id: row.oauth_server_id,
+ userRef: row.user_id,
...fromStoredOAuthPendingAuthorizationData(row.auth_data),
};
}
diff --git a/packages/server/src/db/postgres/token-store/queries/token.ts b/packages/server/src/db/postgres/token-store/queries/token.ts
index b846a84c5..5474fde0e 100644
--- a/packages/server/src/db/postgres/token-store/queries/token.ts
+++ b/packages/server/src/db/postgres/token-store/queries/token.ts
@@ -3,16 +3,20 @@ import type { OAuthToken } from '../../../mcpServerStore';
import { json, now } from '../../sqlExpressions';
import type { Database } from '../../types';
-export async function saveToken(db: Kysely<Database>, params: { id: string; token: OAuthToken }): Promise<void> {
+export async function saveToken(
+ db: Kysely<Database>,
+ params: { id: string; userRef: string; token: OAuthToken },
+): Promise<void> {
await db
.insertInto('oauth_token')
.values({
oauth_server_id: params.id,
+ user_id: params.userRef,
token: json(params.token),
updated_at: now(),
})
.onConflict(oc =>
- oc.column('oauth_server_id').doUpdateSet({
+ oc.columns(['oauth_server_id', 'user_id']).doUpdateSet({
token: sql`excluded.token`,
updated_at: sql`excluded.updated_at`,
}),
@@ -20,17 +24,24 @@ export async function saveToken(db: Kysely<Database>, params: { id: string; toke
.execute();
}
-export async function getToken(db: Kysely<Database>, params: { id: string }): Promise<OAuthToken | undefined> {
+export async function getToken(
+ db: Kysely<Database>,
+ params: { id: string; userRef: string },
+): Promise<OAuthToken | undefined> {
const row = await db
.selectFrom('oauth_token')
.select('token')
.where('oauth_server_id', '=', params.id)
+ .where('user_id', '=', params.userRef)
.executeTakeFirst();
return row === undefined ? undefined : row.token;
}
-export async function getTokens(db: Kysely<Database>, params: { ids: string[] }): Promise<Map<string, OAuthToken>> {
+export async function getTokens(
+ db: Kysely<Database>,
+ params: { ids: string[]; userRef: string },
+): Promise<Map<string, OAuthToken>> {
if (params.ids.length === 0) {
return new Map();
}
@@ -38,11 +49,16 @@ export async function getTokens(db: Kysely<Database>, params: { ids: string[] })
.selectFrom('oauth_token')
.select(['oauth_server_id', 'token'])
.where('oauth_server_id', 'in', params.ids)
+ .where('user_id', '=', params.userRef)
.execute();
return new Map(rows.map(row => [row.oauth_server_id, row.token]));
}
-export async function deleteToken(db: Kysely<Database>, params: { id: string }): Promise<void> {
- await db.deleteFrom('oauth_token').where('oauth_server_id', '=', params.id).execute();
+export async function deleteToken(db: Kysely<Database>, params: { id: string; userRef: string }): Promise<void> {
+ await db
+ .deleteFrom('oauth_token')
+ .where('oauth_server_id', '=', params.id)
+ .where('user_id', '=', params.userRef)
+ .execute();
}
diff --git a/packages/server/src/db/postgres/types.ts b/packages/server/src/db/postgres/types.ts
index aed962da0..322430085 100644
--- a/packages/server/src/db/postgres/types.ts
+++ b/packages/server/src/db/postgres/types.ts
@@ -382,14 +382,15 @@ export interface McpServerTable {
}
/**
- * PRIMARY KEY (oauth_server_id)
- * No `tenant_id` — already 1:1 with tenant via the FK. Any tenant-scoped read resolves
- * `oauth_server_id` through mcp_server (by tenant_id + name) first; this table is never
- * queried by tenant_id directly.
+ * PRIMARY KEY (oauth_server_id, user_id)
+ * No `tenant_id` — already scoped to tenant via the FK. Tokens are per harness user
+ * (`user_id` = `UserContext.userRef`); any tenant-scoped read resolves `oauth_server_id`
+ * through mcp_server (by tenant_id + name) first.
*/
export interface OAuthTokenTable {
/** FK -> mcp_server.id, ON DELETE CASCADE */
oauth_server_id: string;
+ user_id: string;
/** access_token, refresh_token, expires_at, scope. */
token: JSONColumnType<OAuthToken, OAuthToken, OAuthToken>;
updated_at: Date;
@@ -405,6 +406,7 @@ export interface OAuthPendingAuthorizationTable {
id: string;
/** FK -> mcp_server.id, ON DELETE CASCADE */
oauth_server_id: string;
+ user_id: string;
auth_data: JSONColumnType<
OAuthPendingAuthorizationData,
OAuthPendingAuthorizationData,
diff --git a/packages/server/src/db/sqlite/migrations/20260813_000001_mcp_oauth_user_scoped.ts b/packages/server/src/db/sqlite/migrations/20260813_000001_mcp_oauth_user_scoped.ts
new file mode 100644
index 000000000..8ab94995b
--- /dev/null
+++ b/packages/server/src/db/sqlite/migrations/20260813_000001_mcp_oauth_user_scoped.ts
@@ -0,0 +1,72 @@
+import { type Kysely, sql } from 'kysely';
+
+/**
+ * Scope MCP OAuth access/refresh tokens per harness user, and stamp `user_id` on
+ * pending authorizations so the public callback can write the correct token row.
+ * Drops previously shared (server-only) tokens — callers must re-authorize.
+ *
+ * SQLite cannot alter primary keys in place, so the token/pending tables are
+ * rebuilt (empty after the deletes below). Mirrors
+ * db/postgres/migrations/20260813_000001_mcp_oauth_user_scoped.ts.
+ *
+ * SQLite has no LOCK TABLE / ACCESS EXCLUSIVE. Migrations run in a deferred
+ * transaction; a no-op UPDATE before each delete escalates to a RESERVED write
+ * lock so concurrent connections cannot insert until this migration commits.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+ // Escalate deferred txn → RESERVED (writer lock) before clearing the table.
+ await sql`UPDATE oauth_token SET updated_at = updated_at WHERE false`.execute(db);
+ await sql`DELETE FROM oauth_token`.execute(db);
+ await sql`DROP TABLE oauth_token`.execute(db);
+ await sql`
+ CREATE TABLE oauth_token (
+ oauth_server_id TEXT NOT NULL REFERENCES mcp_server (id) ON DELETE CASCADE,
+ user_id TEXT NOT NULL,
+ token BLOB NOT NULL,
+ updated_at TEXT NOT NULL,
+ CONSTRAINT oauth_token_pkey PRIMARY KEY (oauth_server_id, user_id)
+ ) STRICT
+ `.execute(db);
+
+ // In-flight pending rows cannot be attributed to a user; drop them.
+ await sql`UPDATE oauth_pending_authorization SET created_at = created_at WHERE false`.execute(db);
+ await sql`DELETE FROM oauth_pending_authorization`.execute(db);
+ await sql`DROP TABLE oauth_pending_authorization`.execute(db);
+ await sql`
+ CREATE TABLE oauth_pending_authorization (
+ id TEXT NOT NULL,
+ oauth_server_id TEXT NOT NULL REFERENCES mcp_server (id) ON DELETE CASCADE,
+ user_id TEXT NOT NULL,
+ auth_data BLOB NOT NULL,
+ created_at TEXT NOT NULL,
+ CONSTRAINT oauth_pending_authorization_pkey PRIMARY KEY (id)
+ ) STRICT
+ `.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+ await sql`UPDATE oauth_pending_authorization SET created_at = created_at WHERE false`.execute(db);
+ await sql`DELETE FROM oauth_pending_authorization`.execute(db);
+ await sql`DROP TABLE oauth_pending_authorization`.execute(db);
+ await sql`
+ CREATE TABLE oauth_pending_authorization (
+ id TEXT NOT NULL,
+ oauth_server_id TEXT NOT NULL REFERENCES mcp_server (id) ON DELETE CASCADE,
+ auth_data BLOB NOT NULL,
+ created_at TEXT NOT NULL,
+ CONSTRAINT oauth_pending_authorization_pkey PRIMARY KEY (id)
+ ) STRICT
+ `.execute(db);
+
+ await sql`UPDATE oauth_token SET updated_at = updated_at WHERE false`.execute(db);
+ await sql`DELETE FROM oauth_token`.execute(db);
+ await sql`DROP TABLE oauth_token`.execute(db);
+ await sql`
+ CREATE TABLE oauth_token (
+ oauth_server_id TEXT NOT NULL REFERENCES mcp_server (id) ON DELETE CASCADE,
+ token BLOB NOT NULL,
+ updated_at TEXT NOT NULL,
+ CONSTRAINT oauth_token_pkey PRIMARY KEY (oauth_server_id)
+ ) STRICT
+ `.execute(db);
+}
diff --git a/packages/server/src/db/sqlite/token-store/SqliteOAuthTokenStore.ts b/packages/server/src/db/sqlite/token-store/SqliteOAuthTokenStore.ts
index ed00c79d7..2e41bedfe 100644
--- a/packages/server/src/db/sqlite/token-store/SqliteOAuthTokenStore.ts
+++ b/packages/server/src/db/sqlite/token-store/SqliteOAuthTokenStore.ts
@@ -1,5 +1,5 @@
import type { Kysely, Transaction } from 'kysely';
-import type { IOAuthTokenStore, OAuthPendingAuthorization, OAuthToken } from '../../../mcp/auth/types';
+import type { IOAuthTokenStore, OAuthPendingAuthorization, OAuthToken, OAuthTokenKey } from '../../../mcp/auth/types';
import { fromStoredOAuthToken, toStoredOAuthToken } from '../../mcpServerStore';
import type { Database } from '../types';
import { consumePendingAuthorization, savePendingAuthorization } from './queries/pendingAuthorization';
@@ -19,21 +19,28 @@ export class SqliteOAuthTokenStore implements IOAuthTokenStore<Transaction<Datab
return consumePendingAuthorization(transaction ?? this.db, params);
}
- saveToken(params: { id: string; token: OAuthToken }, transaction?: Transaction<Database>): Promise<void> {
- return saveToken(transaction ?? this.db, { id: params.id, token: toStoredOAuthToken(params.token) });
+ saveToken(params: OAuthTokenKey & { token: OAuthToken }, transaction?: Transaction<Database>): Promise<void> {
+ return saveToken(transaction ?? this.db, {
+ id: params.id,
+ userRef: params.userRef,
+ token: toStoredOAuthToken(params.token),
+ });
}
- async getToken(params: { id: string }, transaction?: Transaction<Database>): Promise<OAuthToken | undefined> {
+ async getToken(params: OAuthTokenKey, transaction?: Transaction<Database>): Promise<OAuthToken | undefined> {
const stored = await getToken(transaction ?? this.db, params);
return stored === undefined ? undefined : fromStoredOAuthToken(stored);
}
- async getTokens(params: { ids: string[] }, transaction?: Transaction<Database>): Promise<Map<string, OAuthToken>> {
+ async getTokens(
+ params: { ids: string[]; userRef: string },
+ transaction?: Transaction<Database>,
+ ): Promise<Map<string, OAuthToken>> {
const stored = await getTokens(transaction ?? this.db, params);
return new Map([...stored].map(([id, token]) => [id, fromStoredOAuthToken(token)]));
}
- deleteToken(params: { id: string }, transaction?: Transaction<Database>): Promise<void> {
+ deleteToken(params: OAuthTokenKey, transaction?: Transaction<Database>): Promise<void> {
return deleteToken(transaction ?? this.db, params);
}
}
diff --git a/packages/server/src/db/sqlite/token-store/queries/pendingAuthorization.ts b/packages/server/src/db/sqlite/token-store/queries/pendingAuthorization.ts
index e2f62b297..19bef9901 100644
--- a/packages/server/src/db/sqlite/token-store/queries/pendingAuthorization.ts
+++ b/packages/server/src/db/sqlite/token-store/queries/pendingAuthorization.ts
@@ -13,7 +13,6 @@ export async function savePendingAuthorization(
db: Kysely<Database>,
pending: OAuthPendingAuthorization,
): Promise<void> {
- // `state` and `id` are their own columns; only the remainder goes in the blob.
const authData = toStoredOAuthPendingAuthorizationData(pending);
await db
@@ -21,6 +20,7 @@ export async function savePendingAuthorization(
.values({
id: pending.state,
oauth_server_id: pending.id,
+ user_id: pending.userRef,
auth_data: jsonbBind(authData),
created_at: nowIso(),
})
@@ -39,7 +39,12 @@ export async function consumePendingAuthorization(
.deleteFrom('oauth_pending_authorization')
.where('id', '=', params.state)
.where('created_at', '>', isoMsAgo(PENDING_AUTHORIZATION_TTL_MS))
- .returning(['id', 'oauth_server_id', jsonText<OAuthPendingAuthorizationData>(sql.ref('auth_data')).as('auth_data')])
+ .returning([
+ 'id',
+ 'oauth_server_id',
+ 'user_id',
+ jsonText<OAuthPendingAuthorizationData>(sql.ref('auth_data')).as('auth_data'),
+ ])
.executeTakeFirst();
if (row === undefined) {
@@ -49,6 +54,7 @@ export async function consumePendingAuthorization(
return {
state: row.id,
id: row.oauth_server_id,
+ userRef: row.user_id,
...fromStoredOAuthPendingAuthorizationData(row.auth_data),
};
}
diff --git a/packages/server/src/db/sqlite/token-store/queries/token.ts b/packages/server/src/db/sqlite/token-store/queries/token.ts
index 8fc4be148..90b87c9a1 100644
--- a/packages/server/src/db/sqlite/token-store/queries/token.ts
+++ b/packages/server/src/db/sqlite/token-store/queries/token.ts
@@ -3,16 +3,20 @@ import type { OAuthToken } from '../../../mcpServerStore';
import { jsonbBind, jsonText, nowIso } from '../../sqlExpressions';
import type { Database } from '../../types';
-export async function saveToken(db: Kysely<Database>, params: { id: string; token: OAuthToken }): Promise<void> {
+export async function saveToken(
+ db: Kysely<Database>,
+ params: { id: string; userRef: string; token: OAuthToken },
+): Promise<void> {
await db
.insertInto('oauth_token')
.values({
oauth_server_id: params.id,
+ user_id: params.userRef,
token: jsonbBind(params.token),
updated_at: nowIso(),
})
.onConflict(oc =>
- oc.column('oauth_server_id').doUpdateSet({
+ oc.columns(['oauth_server_id', 'user_id']).doUpdateSet({
token: sql`excluded.token`,
updated_at: sql`excluded.updated_at`,
}),
@@ -20,17 +24,24 @@ export async function saveToken(db: Kysely<Database>, params: { id: string; toke
.execute();
}
-export async function getToken(db: Kysely<Database>, params: { id: string }): Promise<OAuthToken | undefined> {
+export async function getToken(
+ db: Kysely<Database>,
+ params: { id: string; userRef: string },
+): Promise<OAuthToken | undefined> {
const row = await db
.selectFrom('oauth_token')
.select(jsonText<OAuthToken>(sql.ref('token')).as('token'))
.where('oauth_server_id', '=', params.id)
+ .where('user_id', '=', params.userRef)
.executeTakeFirst();
return row === undefined ? undefined : row.token;
}
-export async function getTokens(db: Kysely<Database>, params: { ids: string[] }): Promise<Map<string, OAuthToken>> {
+export async function getTokens(
+ db: Kysely<Database>,
+ params: { ids: string[]; userRef: string },
+): Promise<Map<string, OAuthToken>> {
if (params.ids.length === 0) {
return new Map();
}
@@ -38,11 +49,16 @@ export async function getTokens(db: Kysely<Database>, params: { ids: string[] })
.selectFrom('oauth_token')
.select(['oauth_server_id', jsonText<OAuthToken>(sql.ref('token')).as('token')])
.where('oauth_server_id', 'in', params.ids)
+ .where('user_id', '=', params.userRef)
.execute();
return new Map(rows.map(row => [row.oauth_server_id, row.token]));
}
-export async function deleteToken(db: Kysely<Database>, params: { id: string }): Promise<void> {
- await db.deleteFrom('oauth_token').where('oauth_server_id', '=', params.id).execute();
+export async function deleteToken(db: Kysely<Database>, params: { id: string; userRef: string }): Promise<void> {
+ await db
+ .deleteFrom('oauth_token')
+ .where('oauth_server_id', '=', params.id)
+ .where('user_id', '=', params.userRef)
+ .execute();
}
diff --git a/packages/server/src/db/sqlite/types.ts b/packages/server/src/db/sqlite/types.ts
index 48bf23fda..854b0ca44 100644
--- a/packages/server/src/db/sqlite/types.ts
+++ b/packages/server/src/db/sqlite/types.ts
@@ -231,14 +231,15 @@ export interface McpServerTable {
}
/**
- * PRIMARY KEY (oauth_server_id)
- * No `tenant_id` — already 1:1 with tenant via the FK. Any tenant-scoped read resolves
- * `oauth_server_id` through mcp_server (by tenant_id + name) first; this table is never
- * queried by tenant_id directly.
+ * PRIMARY KEY (oauth_server_id, user_id)
+ * No `tenant_id` — already scoped to tenant via the FK. Tokens are per harness user
+ * (`user_id` = `UserContext.userRef`); any tenant-scoped read resolves `oauth_server_id`
+ * through mcp_server (by tenant_id + name) first.
*/
export interface OAuthTokenTable {
/** FK -> mcp_server.id, ON DELETE CASCADE */
oauth_server_id: string;
+ user_id: string;
token: JsonbColumn<OAuthToken>;
updated_at: string;
}
@@ -250,6 +251,7 @@ export interface OAuthPendingAuthorizationTable {
id: string;
/** FK -> mcp_server.id, ON DELETE CASCADE */
oauth_server_id: string;
+ user_id: string;
/** { mcp_server_url, code_verifier, redirect_url } — same writer/lifecycle, so merged into one column */
auth_data: JsonbColumn<OAuthPendingAuthorizationData>;
created_at: string;
diff --git a/packages/server/src/mcp/auth/inMemoryStores.ts b/packages/server/src/mcp/auth/inMemoryStores.ts
index 9b0cd3eeb..ab0157848 100644
--- a/packages/server/src/mcp/auth/inMemoryStores.ts
+++ b/packages/server/src/mcp/auth/inMemoryStores.ts
@@ -4,10 +4,15 @@ import type {
OAuthClientRecord,
OAuthPendingAuthorization,
OAuthToken,
+ OAuthTokenKey,
} from './types';
const PENDING_AUTHORIZATION_TTL_MS = 10 * 60 * 1000;
+function tokenMapKey(params: OAuthTokenKey): string {
+ return `${params.id}\0${params.userRef}`;
+}
+
/** In-memory OAuth token store for tests and development without a database. */
/* eslint-disable @typescript-eslint/require-await -- synchronous implementation of an async store contract */
export class InMemoryOAuthTokenStore implements IOAuthTokenStore {
@@ -27,18 +32,18 @@ export class InMemoryOAuthTokenStore implements IOAuthTokenStore {
return entry.row;
}
- async saveToken(params: { id: string; token: OAuthToken }): Promise<void> {
- this.tokens.set(params.id, params.token);
+ async saveToken(params: OAuthTokenKey & { token: OAuthToken }): Promise<void> {
+ this.tokens.set(tokenMapKey(params), params.token);
}
- async getToken(params: { id: string }): Promise<OAuthToken | undefined> {
- return this.tokens.get(params.id);
+ async getToken(params: OAuthTokenKey): Promise<OAuthToken | undefined> {
+ return this.tokens.get(tokenMapKey(params));
}
- async getTokens(params: { ids: string[] }): Promise<Map<string, OAuthToken>> {
+ async getTokens(params: { ids: string[]; userRef: string }): Promise<Map<string, OAuthToken>> {
const tokens = new Map<string, OAuthToken>();
for (const id of params.ids) {
- const token = this.tokens.get(id);
+ const token = this.tokens.get(tokenMapKey({ id, userRef: params.userRef }));
if (token !== undefined) {
tokens.set(id, token);
}
@@ -46,8 +51,8 @@ export class InMemoryOAuthTokenStore implements IOAuthTokenStore {
return tokens;
}
- async deleteToken(params: { id: string }): Promise<void> {
- this.tokens.delete(params.id);
+ async deleteToken(params: OAuthTokenKey): Promise<void> {
+ this.tokens.delete(tokenMapKey(params));
}
}
diff --git a/packages/server/src/mcp/auth/mcpDcr.ts b/packages/server/src/mcp/auth/mcpDcr.ts
index d90ead460..912ebb14b 100644
--- a/packages/server/src/mcp/auth/mcpDcr.ts
+++ b/packages/server/src/mcp/auth/mcpDcr.ts
@@ -153,6 +153,7 @@ export async function buildMcpAuthorizationUrl(params: {
tokenStore: IOAuthTokenStore;
mcpServerStore: IOAuthClientStore;
serverId: string;
+ userRef: string;
mcpServerUrl: string;
mcpServerName: string;
clientName: string;
@@ -184,6 +185,7 @@ export async function buildMcpAuthorizationUrl(params: {
await params.tokenStore.savePendingAuthorization({
state,
id: params.serverId,
+ userRef: params.userRef,
mcpServerUrl: params.mcpServerUrl,
codeVerifier: started.codeVerifier,
redirectUrl: params.redirectUrl ?? null,
@@ -195,13 +197,15 @@ export async function resolveMcpAuth(params: {
tokenStore: IOAuthTokenStore;
mcpServerStore: IOAuthClientStore;
serverId: string;
+ userRef: string;
mcpServerUrl: string;
mcpServerName: string;
clientName: string;
redirectUrl?: string;
}): Promise<ResolveMcpAuthResult> {
const nowMs = Date.now();
- const token = await params.tokenStore.getToken({ id: params.serverId });
+ const tokenKey = { id: params.serverId, userRef: params.userRef };
+ const token = await params.tokenStore.getToken(tokenKey);
if (token && isOAuthAccessTokenUsable(token.expiresAt, nowMs)) {
return { headers: { Authorization: `Bearer ${token.accessToken}` } };
}
@@ -216,7 +220,7 @@ export async function resolveMcpAuth(params: {
resource: resourceUrlFromServerUrl(params.mcpServerUrl),
});
const saved = oauthTokensToOAuthToken(refreshed, nowMs, token.refreshToken);
- await params.tokenStore.saveToken({ id: params.serverId, token: saved });
+ await params.tokenStore.saveToken({ ...tokenKey, token: saved });
return { headers: { Authorization: `Bearer ${saved.accessToken}` } };
} catch {
// Refresh failure falls through to a fresh authorization.
@@ -224,12 +228,13 @@ export async function resolveMcpAuth(params: {
}
}
if (token) {
- await params.tokenStore.deleteToken({ id: params.serverId });
+ await params.tokenStore.deleteToken(tokenKey);
}
const authUrl = await buildMcpAuthorizationUrl({
tokenStore: params.tokenStore,
mcpServerStore: params.mcpServerStore,
serverId: params.serverId,
+ userRef: params.userRef,
mcpServerUrl: params.mcpServerUrl,
mcpServerName: params.mcpServerName,
clientName: params.clientName,
@@ -277,7 +282,7 @@ export async function completeMcpAuthorization<TTransaction>(params: {
} catch (error: unknown) {
if (error instanceof InvalidClientError) {
await params.withTransaction(async transaction => {
- await params.tokenStore.deleteToken({ id: pending.id }, transaction);
+ await params.tokenStore.deleteToken({ id: pending.id, userRef: pending.userRef }, transaction);
await params.mcpServerStore.deleteClient({ id: pending.id }, transaction);
});
throw new McpConnectionError('OAuth client registration is invalid; please retry connecting', 400, {
@@ -290,6 +295,7 @@ export async function completeMcpAuthorization<TTransaction>(params: {
}
await params.tokenStore.saveToken({
id: pending.id,
+ userRef: pending.userRef,
token: oauthTokensToOAuthToken(tokens, nowMs, null),
});
}
diff --git a/packages/server/src/mcp/auth/types.ts b/packages/server/src/mcp/auth/types.ts
index 4d366a97e..0f0b047ff 100644
--- a/packages/server/src/mcp/auth/types.ts
+++ b/packages/server/src/mcp/auth/types.ts
@@ -2,12 +2,13 @@
export interface OAuthPendingAuthorization {
state: string;
id: string;
+ userRef: string;
mcpServerUrl: string;
codeVerifier: string | null;
redirectUrl: string | null;
}
-/** Stored access token for one resource. */
+/** Stored access token for one (MCP server, user) pair. */
export interface OAuthToken {
accessToken: string;
refreshToken: string | null;
@@ -15,16 +16,22 @@ export interface OAuthToken {
scope: string | null;
}
+/** Composite key: MCP server row id + harness `UserContext.userRef`. */
+export interface OAuthTokenKey {
+ id: string;
+ userRef: string;
+}
+
export interface IOAuthTokenStore<TTransaction = never> {
savePendingAuthorization(pending: OAuthPendingAuthorization, transaction?: TTransaction): Promise<void>;
consumePendingAuthorization(
params: { state: string },
transaction?: TTransaction,
): Promise<OAuthPendingAuthorization | undefined>;
- saveToken(params: { id: string; token: OAuthToken }, transaction?: TTransaction): Promise<void>;
- getToken(params: { id: string }, transaction?: TTransaction): Promise<OAuthToken | undefined>;
- getTokens(params: { ids: string[] }, transaction?: TTransaction): Promise<Map<string, OAuthToken>>;
- deleteToken(params: { id: string }, transaction?: TTransaction): Promise<void>;
+ saveToken(params: OAuthTokenKey & { token: OAuthToken }, transaction?: TTransaction): Promise<void>;
+ getToken(params: OAuthTokenKey, transaction?: TTransaction): Promise<OAuthToken | undefined>;
+ getTokens(params: { ids: string[]; userRef: string }, transaction?: TTransaction): Promise<Map<string, OAuthToken>>;
+ deleteToken(params: OAuthTokenKey, transaction?: TTransaction): Promise<void>;
}
/** Authorization-server endpoints discovered and cached at registration time. */
diff --git a/packages/server/src/runtime/sessionResources.ts b/packages/server/src/runtime/sessionResources.ts
index ead021b36..ea058fda8 100644
--- a/packages/server/src/runtime/sessionResources.ts
+++ b/packages/server/src/runtime/sessionResources.ts
@@ -91,13 +91,15 @@ function dcrHeadersResolver(params: {
tokenStore: IOAuthTokenStore;
mcpServerStore: IMcpServerStore;
clientName: string;
+ userRef: string;
}): RemoteMcpHeaders {
- const { record, tokenStore, mcpServerStore, clientName } = params;
+ const { record, tokenStore, mcpServerStore, clientName, userRef } = params;
return async () => {
const result = await resolveMcpAuth({
tokenStore,
mcpServerStore,
serverId: record.id,
+ userRef,
mcpServerUrl: record.manifest.url,
mcpServerName: record.name,
clientName,
@@ -126,12 +128,14 @@ export async function getMcpConnection({
store,
tokenStore,
clientName,
+ userRef,
}: {
tenant_id: string;
name: string;
store: IMcpServerStore;
tokenStore: IOAuthTokenStore;
clientName: string;
+ userRef: string;
}): Promise<McpConnection | undefined> {
const record = await store.getServer({ tenant_id, name });
if (record === undefined) {
@@ -145,6 +149,7 @@ export async function getMcpConnection({
tokenStore,
mcpServerStore: store,
clientName,
+ userRef,
}),
};
}
diff --git a/packages/server/src/schemas/mcpServer.ts b/packages/server/src/schemas/mcpServer.ts
index 2c75693fb..c054951e1 100644
--- a/packages/server/src/schemas/mcpServer.ts
+++ b/packages/server/src/schemas/mcpServer.ts
@@ -7,7 +7,6 @@
* turn execution resolves DCR tokens via resolveMcpAuth.
*/
import { z } from '@hono/zod-openapi';
-import { isOAuthAccessTokenUsable } from '../mcp/auth/mcpOAuthHelpers';
import type { OAuthToken } from '../mcp/auth/types';
import { NameSchema } from './common';
@@ -78,11 +77,23 @@ export const ListMcpServersResponseSchema = z
.object({ data: z.array(ConfiguredMcpServerSchema) })
.openapi('ListMcpServersResponse');
-/** Chat/composer read view — no auth or auth_status. */
+/** Public auth mechanism for chat/composer (no secrets). */
+export const McpServerAuthPublicSchema = z
+ .discriminatedUnion('type', [
+ z.object({ type: z.literal('dcr') }).strict(),
+ z.object({ type: z.literal('header') }).strict(),
+ ])
+ .openapi('McpServerAuthPublic');
+
+/** Chat/composer read view — public fields plus per-user auth_status. */
export const McpServerReadEntrySchema = z
.object({
name: NameSchema,
url: z.url().describe('URL of the remote MCP server.'),
+ auth: McpServerAuthPublicSchema.optional().describe(
+ 'Auth mechanism when configured (no secrets). Omit when the server needs no credentials.',
+ ),
+ auth_status: McpAuthStatusSchema.describe('Auth state for the calling user.'),
})
.strict()
.openapi('McpServerReadEntry');
@@ -95,6 +106,7 @@ export type McpServerType = z.infer<typeof McpServerTypeSchema>;
export type McpServerAuthSettings = z.infer<typeof McpServerAuthSettingsSchema>;
export type McpServerManifest = z.infer<typeof McpServerManifestSchema>;
export type McpAuthStatus = z.infer<typeof McpAuthStatusSchema>;
+export type McpServerAuthPublic = z.infer<typeof McpServerAuthPublicSchema>;
export type ConfiguredMcpServer = z.infer<typeof ConfiguredMcpServerSchema>;
export type McpServerReadEntry = z.infer<typeof McpServerReadEntrySchema>;
@@ -113,15 +125,12 @@ export function resolveConfiguredMcpRequestHeaders(manifest: McpServerManifest):
export function resolveMcpAuthStatus({
manifest,
token,
- nowMs = Date.now(),
}: {
manifest: McpServerManifest;
token?: OAuthToken;
- nowMs?: number;
}): McpAuthStatus {
if (manifest.auth?.type === 'dcr') {
- const authenticated = token && isOAuthAccessTokenUsable(token.expiresAt, nowMs);
- return authenticated ? { status: 'authenticated' } : { status: 'auth_required' };
+ return token ? { status: 'authenticated' } : { status: 'auth_required' };
}
if (manifest.auth?.type === 'header') {
return { status: 'authenticated' };
diff --git a/packages/server/tests/db/oauthTokenStoreContractSuite.ts b/packages/server/tests/db/oauthTokenStoreContractSuite.ts
index 7f1944099..19e7b3bf3 100644
--- a/packages/server/tests/db/oauthTokenStoreContractSuite.ts
+++ b/packages/server/tests/db/oauthTokenStoreContractSuite.ts
@@ -4,7 +4,7 @@
*
* The store's rows are FK'd to `mcp_server.id`, and pending authorizations expire on read, so
* each backend supplies `seedResource` (create the FK parent) and `expirePending` (backdate a
- * pending row past its TTL).
+ * pending row past its TTL). Tokens are scoped per (resource id, userRef).
*/
import type { IOAuthTokenStore, OAuthPendingAuthorization, OAuthToken } from '../../src/mcp/auth/types';
@@ -16,6 +16,8 @@ export interface OAuthTokenStoreHarness {
const RESOURCE_ID = 'mcp-server-1';
const OTHER_RESOURCE_ID = 'mcp-server-2';
+const USER_REF = 'user-a';
+const OTHER_USER_REF = 'user-b';
function token(overrides: Partial<OAuthToken> = {}): OAuthToken {
return {
@@ -31,6 +33,7 @@ function pending(overrides: Partial<OAuthPendingAuthorization> = {}): OAuthPendi
return {
state: 'state-1',
id: RESOURCE_ID,
+ userRef: USER_REF,
mcpServerUrl: 'https://mcp.example.com/sse',
codeVerifier: 'verifier-1',
redirectUrl: 'https://app.example.com/done',
@@ -44,47 +47,55 @@ export function runOAuthTokenStoreContractSuite(getHarness: () => OAuthTokenStor
await h.seedResource(RESOURCE_ID);
const saved = token({ refreshToken: null, scope: null });
- await h.store.saveToken({ id: RESOURCE_ID, token: saved });
+ await h.store.saveToken({ id: RESOURCE_ID, userRef: USER_REF, token: saved });
- expect(await h.store.getToken({ id: RESOURCE_ID })).toEqual(saved);
+ expect(await h.store.getToken({ id: RESOURCE_ID, userRef: USER_REF })).toEqual(saved);
});
- it('saveToken replaces the token for an existing resource', async () => {
+ it('saveToken replaces the token for an existing resource+user', async () => {
const h = getHarness();
await h.seedResource(RESOURCE_ID);
- await h.store.saveToken({ id: RESOURCE_ID, token: token() });
+ await h.store.saveToken({ id: RESOURCE_ID, userRef: USER_REF, token: token() });
- await h.store.saveToken({ id: RESOURCE_ID, token: token({ accessToken: 'access-2' }) });
+ await h.store.saveToken({ id: RESOURCE_ID, userRef: USER_REF, token: token({ accessToken: 'access-2' }) });
- expect(await h.store.getToken({ id: RESOURCE_ID })).toEqual(token({ accessToken: 'access-2' }));
+ expect(await h.store.getToken({ id: RESOURCE_ID, userRef: USER_REF })).toEqual(token({ accessToken: 'access-2' }));
});
it('getToken is undefined before save and after delete', async () => {
const h = getHarness();
await h.seedResource(RESOURCE_ID);
- expect(await h.store.getToken({ id: RESOURCE_ID })).toBeUndefined();
+ expect(await h.store.getToken({ id: RESOURCE_ID, userRef: USER_REF })).toBeUndefined();
- await h.store.saveToken({ id: RESOURCE_ID, token: token() });
- await h.store.deleteToken({ id: RESOURCE_ID });
+ await h.store.saveToken({ id: RESOURCE_ID, userRef: USER_REF, token: token() });
+ await h.store.deleteToken({ id: RESOURCE_ID, userRef: USER_REF });
- expect(await h.store.getToken({ id: RESOURCE_ID })).toBeUndefined();
+ expect(await h.store.getToken({ id: RESOURCE_ID, userRef: USER_REF })).toBeUndefined();
});
- it('getTokens batches only the ids that have a stored token', async () => {
+ it('getTokens batches only the ids that have a stored token for the user', async () => {
const h = getHarness();
await h.seedResource(RESOURCE_ID);
await h.seedResource(OTHER_RESOURCE_ID);
const first = token();
- await h.store.saveToken({ id: RESOURCE_ID, token: first });
-
- const found = await h.store.getTokens({ ids: [RESOURCE_ID, OTHER_RESOURCE_ID, 'mcp-server-absent'] });
+ await h.store.saveToken({ id: RESOURCE_ID, userRef: USER_REF, token: first });
+ await h.store.saveToken({
+ id: OTHER_RESOURCE_ID,
+ userRef: OTHER_USER_REF,
+ token: token({ accessToken: 'other-user' }),
+ });
+
+ const found = await h.store.getTokens({
+ ids: [RESOURCE_ID, OTHER_RESOURCE_ID, 'mcp-server-absent'],
+ userRef: USER_REF,
+ });
expect(found).toEqual(new Map([[RESOURCE_ID, first]]));
});
it('getTokens returns an empty map for no ids', async () => {
const h = getHarness();
- expect(await h.store.getTokens({ ids: [] })).toEqual(new Map());
+ expect(await h.store.getTokens({ ids: [], userRef: USER_REF })).toEqual(new Map());
});
it('tokens are scoped per resource', async () => {
@@ -92,13 +103,30 @@ export function runOAuthTokenStoreContractSuite(getHarness: () => OAuthTokenStor
await h.seedResource(RESOURCE_ID);
await h.seedResource(OTHER_RESOURCE_ID);
const other = token({ accessToken: 'access-other' });
- await h.store.saveToken({ id: RESOURCE_ID, token: token() });
- await h.store.saveToken({ id: OTHER_RESOURCE_ID, token: other });
+ await h.store.saveToken({ id: RESOURCE_ID, userRef: USER_REF, token: token() });
+ await h.store.saveToken({ id: OTHER_RESOURCE_ID, userRef: USER_REF, token: other });
+
+ await h.store.deleteToken({ id: RESOURCE_ID, userRef: USER_REF });
+
+ expect(await h.store.getToken({ id: RESOURCE_ID, userRef: USER_REF })).toBeUndefined();
+ expect(await h.store.getToken({ id: OTHER_RESOURCE_ID, userRef: USER_REF })).toEqual(other);
+ });
+
+ it('tokens are scoped per user on the same resource', async () => {
+ const h = getHarness();
+ await h.seedResource(RESOURCE_ID);
+ const forA = token({ accessToken: 'access-a' });
+ const forB = token({ accessToken: 'access-b' });
+ await h.store.saveToken({ id: RESOURCE_ID, userRef: USER_REF, token: forA });
+ await h.store.saveToken({ id: RESOURCE_ID, userRef: OTHER_USER_REF, token: forB });
+
+ expect(await h.store.getToken({ id: RESOURCE_ID, userRef: USER_REF })).toEqual(forA);
+ expect(await h.store.getToken({ id: RESOURCE_ID, userRef: OTHER_USER_REF })).toEqual(forB);
- await h.store.deleteToken({ id: RESOURCE_ID });
+ await h.store.deleteToken({ id: RESOURCE_ID, userRef: USER_REF });
- expect(await h.store.getToken({ id: RESOURCE_ID })).toBeUndefined();
- expect(await h.store.getToken({ id: OTHER_RESOURCE_ID })).toEqual(other);
+ expect(await h.store.getToken({ id: RESOURCE_ID, userRef: USER_REF })).toBeUndefined();
+ expect(await h.store.getToken({ id: RESOURCE_ID, userRef: OTHER_USER_REF })).toEqual(forB);
});
it('savePendingAuthorization + consumePendingAuthorization round-trips, including null fields', async () => {
@@ -129,7 +157,12 @@ export function runOAuthTokenStoreContractSuite(getHarness: () => OAuthTokenStor
const h = getHarness();
await h.seedResource(RESOURCE_ID);
await h.seedResource(OTHER_RESOURCE_ID);
- const other = pending({ state: 'state-2', id: OTHER_RESOURCE_ID, codeVerifier: 'verifier-2' });
+ const other = pending({
+ state: 'state-2',
+ id: OTHER_RESOURCE_ID,
+ userRef: OTHER_USER_REF,
+ codeVerifier: 'verifier-2',
+ });
await h.store.savePendingAuthorization(pending());
await h.store.savePendingAuthorization(other);
diff --git a/packages/server/tests/unit/apis/mcpOAuth.test.ts b/packages/server/tests/unit/apis/mcpOAuth.test.ts
index ee7f037e3..59a6f16c8 100644
--- a/packages/server/tests/unit/apis/mcpOAuth.test.ts
+++ b/packages/server/tests/unit/apis/mcpOAuth.test.ts
@@ -5,6 +5,7 @@
import winston from 'winston';
import { createMcpOAuthRouter } from '../../../src/apis/mcpOAuth';
import { createMcpServersRouter, createSettingsMcpServersRouter } from '../../../src/apis/mcpServers';
+import { LOCAL_USER_CONTEXT } from '../../../src/auth/identity';
import { McpCatalog } from '../../../src/catalog/McpCatalog';
import { migrateSqliteToLatest } from '../../../src/db/migrateSqlite';
import { createSqliteDb } from '../../../src/db/sqlite/client';
@@ -77,30 +78,35 @@ describe('MCP OAuth authorize + callback', () => {
let oauthRouter: ReturnType<typeof createMcpOAuthRouter>;
let mcpServerStore: SqliteMcpServerStore;
let tokenStore: SqliteOAuthTokenStore;
+ let withTransaction: <T>(callback: (transaction: unknown) => Promise<T>) => Promise<T>;
+ let logger: ReturnType<typeof winston.createLogger>;
beforeAll(async () => {
const db = createSqliteDb(':memory:');
await migrateSqliteToLatest(db);
mcpServerStore = new SqliteMcpServerStore(db);
tokenStore = new SqliteOAuthTokenStore(db);
- const logger = winston.createLogger({ silent: true });
+ withTransaction = callback => db.transaction().execute(callback);
+ logger = winston.createLogger({ silent: true });
settingsRouter = createSettingsMcpServersRouter({
mcpCatalog: McpCatalog.load(),
mcpServerStore,
tokenStore,
- withTransaction: callback => db.transaction().execute(callback),
+ withTransaction,
logger,
+ resolveUserContext: () => LOCAL_USER_CONTEXT,
});
mcpServersRouter = createMcpServersRouter({
mcpServerStore,
tokenStore,
- withTransaction: callback => db.transaction().execute(callback),
+ withTransaction,
logger,
+ resolveUserContext: () => LOCAL_USER_CONTEXT,
});
oauthRouter = createMcpOAuthRouter({
tokenStore,
mcpServerStore,
- withTransaction: callback => db.transaction().execute(callback),
+ withTransaction,
logger,
});
});
@@ -165,7 +171,7 @@ describe('MCP OAuth authorize + callback', () => {
const record = await mcpServerStore.getServer({ tenant_id: 'default', name: 'oauth-mcp' });
expect(record).toBeDefined();
- const token = await tokenStore.getToken({ id: record?.id ?? '' });
+ const token = await tokenStore.getToken({ id: record?.id ?? '', userRef: LOCAL_USER_CONTEXT.userRef });
expect(token?.accessToken).toBe('access-1');
expect(token?.refreshToken).toBe('refresh-1');
@@ -205,4 +211,46 @@ describe('MCP OAuth authorize + callback', () => {
expect(callback.status).toBe(200);
expect(await callback.json()).toEqual({ success: true });
});
+
+ it('authorize for one user does not authenticate another user on the same server', async () => {
+ const otherRouter = createMcpServersRouter({
+ mcpServerStore,
+ tokenStore,
+ withTransaction,
+ logger,
+ resolveUserContext: () => ({ userRef: 'other-user', role: 'user' }),
+ });
+
+ const put = await settingsRouter.request('/', {
+ method: 'PUT',
+ headers: { 'content-type': 'application/json' },
+ body: JSON.stringify({
+ type: 'remote',
+ name: 'oauth-mcp-scoped',
+ url: MCP_URL,
+ auth: { type: 'dcr' },
+ }),
+ });
+ expect(put.status).toBe(200);
+
+ const authorizeA = await mcpServersRouter.request(
+ `/oauth-mcp-scoped/authorize?redirect_url=${encodeURIComponent(FE_REDIRECT)}`,
+ );
+ expect(authorizeA.status).toBe(200);
+ const authorizeABody = (await authorizeA.json()) as { authorization_url?: string };
+ const state = new URL(authorizeABody.authorization_url ?? '').searchParams.get('state');
+ expect(state).toBeTruthy();
+
+ const callback = await oauthRouter.request(`/callback?state=${encodeURIComponent(state ?? '')}&code=auth-code-1`);
+ expect(callback.status).toBe(302);
+
+ const reauthorizeA = await mcpServersRouter.request('/oauth-mcp-scoped/authorize');
+ expect(await reauthorizeA.json()).toEqual({ status: 'authenticated' });
+
+ const authorizeB = await otherRouter.request('/oauth-mcp-scoped/authorize');
+ expect(authorizeB.status).toBe(200);
+ const authorizeBBody = (await authorizeB.json()) as { status: string; authorization_url?: string };
+ expect(authorizeBBody.status).toBe('auth_required');
+ expect(authorizeBBody.authorization_url).toBeDefined();
+ });
});
diff --git a/packages/server/tests/unit/apis/mcpServers.test.ts b/packages/server/tests/unit/apis/mcpServers.test.ts
index 02b285883..c02e96ca9 100644
--- a/packages/server/tests/unit/apis/mcpServers.test.ts
+++ b/packages/server/tests/unit/apis/mcpServers.test.ts
@@ -1,6 +1,7 @@
import winston from 'winston';
import { createMcpServersRouter, createSettingsMcpServersRouter } from '../../../src/apis/mcpServers';
import { TENANT_ID } from '../../../src/apis/sessions';
+import { LOCAL_USER_CONTEXT } from '../../../src/auth/identity';
import { McpCatalog } from '../../../src/catalog/McpCatalog';
import { migrateSqliteToLatest } from '../../../src/db/migrateSqlite';
import { createSqliteDb } from '../../../src/db/sqlite/client';
@@ -43,6 +44,8 @@ describe('mcp-servers routers', () => {
let mcpServersRouter: ReturnType<typeof createMcpServersRouter>;
let mcpServerStore: SqliteMcpServerStore;
let tokenStore: SqliteOAuthTokenStore;
+ let withTransaction: <T>(callback: (transaction: unknown) => Promise<T>) => Promise<T>;
+ let logger: ReturnType<typeof winston.createLogger>;
const originalFetch = globalThis.fetch;
beforeAll(async () => {
@@ -55,19 +58,22 @@ describe('mcp-servers routers', () => {
await migrateSqliteToLatest(db);
mcpServerStore = new SqliteMcpServerStore(db);
tokenStore = new SqliteOAuthTokenStore(db);
- const logger = winston.createLogger({ silent: true });
+ withTransaction = callback => db.transaction().execute(callback);
+ logger = winston.createLogger({ silent: true });
settingsRouter = createSettingsMcpServersRouter({
mcpCatalog: McpCatalog.load(),
mcpServerStore,
tokenStore,
- withTransaction: callback => db.transaction().execute(callback),
+ withTransaction,
logger,
+ resolveUserContext: () => LOCAL_USER_CONTEXT,
});
mcpServersRouter = createMcpServersRouter({
mcpServerStore,
tokenStore,
- withTransaction: callback => db.transaction().execute(callback),
+ withTransaction,
logger,
+ resolveUserContext: () => LOCAL_USER_CONTEXT,
});
});
@@ -122,13 +128,14 @@ describe('mcp-servers routers', () => {
});
});
- it('DCR server reads authenticated once an unexpired token is stored, auth_required once expired', async () => {
+ it('DCR server reads authenticated when a token row exists, auth_required once deleted', async () => {
await settingsRouter.request('/', putInit(putBodyWithDcr));
const record = await mcpServerStore.getServer({ tenant_id: TENANT_ID, name: putBodyWithDcr.name });
if (record === undefined) throw new Error('expected DCR server to exist');
await tokenStore.saveToken({
id: record.id,
+ userRef: LOCAL_USER_CONTEXT.userRef,
token: {
accessToken: 'access-1',
refreshToken: 'refresh-1',
@@ -143,8 +150,10 @@ describe('mcp-servers routers', () => {
status: 'authenticated',
});
+ // List auth_status is presence-based; expiry is handled at resolve/refresh time.
await tokenStore.saveToken({
id: record.id,
+ userRef: LOCAL_USER_CONTEXT.userRef,
token: {
accessToken: 'access-1',
refreshToken: 'refresh-1',
@@ -156,10 +165,16 @@ describe('mcp-servers routers', () => {
const expired = await settingsRouter.request('/');
const expiredBody = (await expired.json()) as { data: { name: string; auth_status: { status: string } }[] };
expect(expiredBody.data.find(server => server.name === putBodyWithDcr.name)?.auth_status).toEqual({
- status: 'auth_required',
+ status: 'authenticated',
});
- await tokenStore.deleteToken({ id: record.id });
+ await tokenStore.deleteToken({ id: record.id, userRef: LOCAL_USER_CONTEXT.userRef });
+
+ const cleared = await settingsRouter.request('/');
+ const clearedBody = (await cleared.json()) as { data: { name: string; auth_status: { status: string } }[] };
+ expect(clearedBody.data.find(server => server.name === putBodyWithDcr.name)?.auth_status).toEqual({
+ status: 'auth_required',
+ });
});
it('PUT re-upsert of a DCR server reports authenticated when a usable token already exists', async () => {
@@ -170,6 +185,7 @@ describe('mcp-servers routers', () => {
await tokenStore.saveToken({
id: record.id,
+ userRef: LOCAL_USER_CONTEXT.userRef,
token: {
accessToken: 'access-1',
refreshToken: 'refresh-1',
@@ -185,7 +201,7 @@ describe('mcp-servers routers', () => {
data: { ...putBodyWithDcr, auth_status: { status: 'authenticated' } },
});
- await tokenStore.deleteToken({ id: record.id });
+ await tokenStore.deleteToken({ id: record.id, userRef: LOCAL_USER_CONTEXT.userRef });
});
it('PUT with header auth stores headers and reports authenticated', async () => {
@@ -196,12 +212,76 @@ describe('mcp-servers routers', () => {
});
});
- it('GET / on the chat router returns the slim projection without auth fields', async () => {
+ it('GET / on the chat router returns per-user auth_status and public auth type', async () => {
const response = await mcpServersRouter.request('/');
expect(response.status).toBe(200);
- const body = (await response.json()) as { data: { name: string; url: string }[] };
- expect(body.data.map(server => server.name).sort()).toEqual(['deepwiki', 'linear', 'private-mcp']);
- expect(body.data.every(server => Object.keys(server).sort().join(',') === 'name,url')).toBe(true);
+ const body = (await response.json()) as {
+ data: {
+ name: string;
+ url: string;
+ auth?: { type: string };
+ auth_status: { status: string };
+ }[];
+ };
+ const byName = new Map(body.data.map(server => [server.name, server]));
+
+ expect(byName.get('deepwiki')).toEqual({
+ name: 'deepwiki',
+ url: putBody.url,
+ auth_status: { status: 'not_required' },
+ });
+ expect(byName.get('linear')).toEqual({
+ name: 'linear',
+ url: putBodyWithDcr.url,
+ auth: { type: 'dcr' },
+ auth_status: { status: 'auth_required' },
+ });
+ expect(byName.get('private-mcp')).toEqual({
+ name: 'private-mcp',
+ url: putBodyWithHeaderAuth.url,
+ auth: { type: 'header' },
+ auth_status: { status: 'authenticated' },
+ });
+ });
+
+ it('GET / chat list auth_status is scoped to the calling user', async () => {
+ const record = await mcpServerStore.getServer({ tenant_id: TENANT_ID, name: putBodyWithDcr.name });
+ if (record === undefined) throw new Error('expected DCR server to exist');
+ await tokenStore.saveToken({
+ id: record.id,
+ userRef: LOCAL_USER_CONTEXT.userRef,
+ token: {
+ accessToken: 'access-1',
+ refreshToken: 'refresh-1',
+ expiresAt: '2099-01-01T00:00:00.000Z',
+ scope: null,
+ },
+ });
+
+ const forLocal = await mcpServersRouter.request('/');
+ const localBody = (await forLocal.json()) as {
+ data: { name: string; auth_status: { status: string } }[];
+ };
+ expect(localBody.data.find(server => server.name === putBodyWithDcr.name)?.auth_status).toEqual({
+ status: 'authenticated',
+ });
+
+ const otherRouter = createMcpServersRouter({
+ mcpServerStore,
+ tokenStore,
+ withTransaction,
+ logger,
+ resolveUserContext: () => ({ userRef: 'other-user', role: 'user' }),
+ });
+ const forOther = await otherRouter.request('/');
+ const otherBody = (await forOther.json()) as {
+ data: { name: string; auth_status: { status: string } }[];
+ };
+ expect(otherBody.data.find(server => server.name === putBodyWithDcr.name)?.auth_status).toEqual({
+ status: 'auth_required',
+ });
+
+ await tokenStore.deleteToken({ id: record.id, userRef: LOCAL_USER_CONTEXT.userRef });
});
it('PUT rejects invalid bodies at the Zod layer', async () => {
@@ -387,6 +467,7 @@ describe('mcp-servers routers', () => {
});
await tokenStore.saveToken({
id: record.id,
+ userRef: LOCAL_USER_CONTEXT.userRef,
token: {
accessToken: 'access-1',
refreshToken: 'refresh-1',
@@ -400,7 +481,7 @@ describe('mcp-servers routers', () => {
expect(await response.json()).toEqual({
data: { ...putBodyWithDcr, auth_status: { status: 'auth_required' } },
});
- expect(await tokenStore.getToken({ id: record.id })).toBeUndefined();
+ expect(await tokenStore.getToken({ id: record.id, userRef: LOCAL_USER_CONTEXT.userRef })).toBeUndefined();
expect(await mcpServerStore.getClient({ id: record.id })).toEqual({
server: {
authorizationEndpoint: 'https://auth.example.com/authorize',
diff --git a/packages/server/tests/unit/apis/modelProviders.test.ts b/packages/server/tests/unit/apis/modelProviders.test.ts
index 62b68b4ec..aee681ea7 100644
--- a/packages/server/tests/unit/apis/modelProviders.test.ts
+++ b/packages/server/tests/unit/apis/modelProviders.test.ts
@@ -1,6 +1,7 @@
import winston from 'winston';
import { createModelsRouter } from '../../../src/apis/models';
import { createSettingsRouter } from '../../../src/apis/settings';
+import { LOCAL_USER_CONTEXT } from '../../../src/auth/identity';
import { McpCatalog } from '../../../src/catalog/McpCatalog';
import { ModelCatalog } from '../../../src/catalog/ModelCatalog';
import { SandboxCatalog } from '../../../src/catalog/SandboxCatalog';
@@ -64,6 +65,7 @@ async function createRouters(): Promise<{
sandboxProviderStore: new SqliteSandboxProviderStore(db),
withTransaction: callback => db.transaction().execute(callback),
logger: winston.createLogger({ silent: true }),
+ resolveUserContext: () => LOCAL_USER_CONTEXT,
}),
modelsRouter: createModelsRouter({
modelProviderStore,
diff --git a/packages/server/tests/unit/mcp/auth/mcpOAuth.test.ts b/packages/server/tests/unit/mcp/auth/mcpOAuth.test.ts
index 63d5b8c57..35d201f1a 100644
--- a/packages/server/tests/unit/mcp/auth/mcpOAuth.test.ts
+++ b/packages/server/tests/unit/mcp/auth/mcpOAuth.test.ts
@@ -39,6 +39,7 @@ const SERVER_URL = 'https://mcp.example.com/sse';
const AS_ORIGIN = 'https://auth.example.com';
const SERVER_ID = 'mcp-server-id-1';
const SERVER_NAME = 'svc';
+const USER_REF = 'user-a';
const realFetch = globalThis.fetch;
const previousPublicBaseUrl = configuration.PUBLIC_BASE_URL;
@@ -335,6 +336,7 @@ describe('buildMcpAuthorizationUrl', () => {
tokenStore,
mcpServerStore,
serverId: SERVER_ID,
+ userRef: USER_REF,
mcpServerUrl: SERVER_URL,
mcpServerName: SERVER_NAME,
clientName: CLIENT_NAME,
@@ -355,6 +357,7 @@ describe('buildMcpAuthorizationUrl', () => {
expect(pending).toMatchObject({
state,
id: SERVER_ID,
+ userRef: USER_REF,
mcpServerUrl: SERVER_URL,
redirectUrl: 'https://app.example.com/after',
});
@@ -375,6 +378,7 @@ describe('buildMcpAuthorizationUrl', () => {
tokenStore,
mcpServerStore,
serverId: SERVER_ID,
+ userRef: USER_REF,
mcpServerUrl: SERVER_URL,
mcpServerName: SERVER_NAME,
clientName: CLIENT_NAME,
@@ -415,6 +419,7 @@ describe('buildMcpAuthorizationUrl', () => {
tokenStore,
mcpServerStore,
serverId: SERVER_ID,
+ userRef: USER_REF,
mcpServerUrl: SERVER_URL,
mcpServerName: SERVER_NAME,
clientName: CLIENT_NAME,
@@ -431,6 +436,7 @@ const resolveParams = (stores: Stores, mcpServerUrl = SERVER_URL) => ({
tokenStore: stores.tokenStore,
mcpServerStore: stores.mcpServerStore,
serverId: SERVER_ID,
+ userRef: USER_REF,
mcpServerUrl,
mcpServerName: SERVER_NAME,
clientName: CLIENT_NAME,
@@ -441,6 +447,7 @@ describe('resolveMcpAuth', () => {
const stores = newStores();
await stores.tokenStore.saveToken({
id: SERVER_ID,
+ userRef: USER_REF,
token: {
accessToken: 'live-token',
refreshToken: null,
@@ -454,11 +461,35 @@ describe('resolveMcpAuth', () => {
expect(result).toEqual({ headers: { Authorization: 'Bearer live-token' } });
});
+ it("does not reuse another user's token for the same server", async () => {
+ const stores = newStores();
+ await stores.mcpServerStore.saveClient({ id: SERVER_ID, record: sampleClient });
+ await stores.tokenStore.saveToken({
+ id: SERVER_ID,
+ userRef: 'other-user',
+ token: {
+ accessToken: 'other-user-token',
+ refreshToken: null,
+ expiresAt: new Date(Date.now() + 10 * 60_000).toISOString(),
+ scope: null,
+ },
+ });
+ stubOauthFetch({});
+
+ const result = await resolveMcpAuth(resolveParams(stores));
+
+ expect(isMcpAuthRequired(result)).toBe(true);
+ expect(await stores.tokenStore.getToken({ id: SERVER_ID, userRef: 'other-user' })).toMatchObject({
+ accessToken: 'other-user-token',
+ });
+ });
+
it('refreshes an expired token when a refresh_token is stored', async () => {
const stores = newStores();
await stores.mcpServerStore.saveClient({ id: SERVER_ID, record: sampleClient });
await stores.tokenStore.saveToken({
id: SERVER_ID,
+ userRef: USER_REF,
token: {
accessToken: 'old-access',
refreshToken: 'old-refresh',
@@ -483,7 +514,7 @@ describe('resolveMcpAuth', () => {
// Secret present → client_secret_post (form body), not HTTP Basic.
expect(String(tokenBodies[0])).toContain('client_secret=cached-secret');
expect(tokenAuthHeaders[0]).toBe('');
- const saved = await stores.tokenStore.getToken({ id: SERVER_ID });
+ const saved = await stores.tokenStore.getToken({ id: SERVER_ID, userRef: USER_REF });
expect(saved?.accessToken).toBe('new-access');
expect(saved?.refreshToken).toBe('new-refresh');
});
@@ -493,6 +524,7 @@ describe('resolveMcpAuth', () => {
await stores.mcpServerStore.saveClient({ id: SERVER_ID, record: sampleClient });
await stores.tokenStore.saveToken({
id: SERVER_ID,
+ userRef: USER_REF,
token: {
accessToken: 'old-access',
refreshToken: 'old-refresh',
@@ -513,7 +545,7 @@ describe('resolveMcpAuth', () => {
const afterMs = Date.now();
expect(result).toEqual({ headers: { Authorization: 'Bearer new-access' } });
- const saved = await stores.tokenStore.getToken({ id: SERVER_ID });
+ const saved = await stores.tokenStore.getToken({ id: SERVER_ID, userRef: USER_REF });
const expiresAtMs = Date.parse(saved!.expiresAt);
expect(expiresAtMs).toBeGreaterThanOrEqual(beforeMs + DEFAULT_MCP_ACCESS_TOKEN_TTL_SECONDS * 1000);
expect(expiresAtMs).toBeLessThanOrEqual(afterMs + DEFAULT_MCP_ACCESS_TOKEN_TTL_SECONDS * 1000);
@@ -527,6 +559,7 @@ describe('resolveMcpAuth', () => {
await stores.mcpServerStore.saveClient({ id: SERVER_ID, record: sampleClient });
await stores.tokenStore.saveToken({
id: SERVER_ID,
+ userRef: USER_REF,
token: {
accessToken: 'old-access',
refreshToken: 'old-refresh',
@@ -541,7 +574,7 @@ describe('resolveMcpAuth', () => {
expect(isMcpAuthRequired(result)).toBe(true);
if (!isMcpAuthRequired(result)) throw new Error('unreachable');
expect(result.authUrl).toBeInstanceOf(URL);
- expect(await stores.tokenStore.getToken({ id: SERVER_ID })).toBeUndefined();
+ expect(await stores.tokenStore.getToken({ id: SERVER_ID, userRef: USER_REF })).toBeUndefined();
expect(await stores.mcpServerStore.getClient({ id: SERVER_ID })).toEqual(sampleClient);
});
@@ -550,6 +583,7 @@ describe('resolveMcpAuth', () => {
await stores.mcpServerStore.saveClient({ id: SERVER_ID, record: sampleClient });
await stores.tokenStore.saveToken({
id: SERVER_ID,
+ userRef: USER_REF,
token: {
accessToken: 'old-access',
refreshToken: null,
@@ -565,7 +599,7 @@ describe('resolveMcpAuth', () => {
if (!isMcpAuthRequired(result)) throw new Error('unreachable');
expect(result.authUrl).toBeInstanceOf(URL);
expect(result.authUrl.href).toContain('/authorize');
- expect(await stores.tokenStore.getToken({ id: SERVER_ID })).toBeUndefined();
+ expect(await stores.tokenStore.getToken({ id: SERVER_ID, userRef: USER_REF })).toBeUndefined();
expect(await stores.mcpServerStore.getClient({ id: SERVER_ID })).toEqual(sampleClient);
});
@@ -645,7 +679,7 @@ describe('completeMcpAuthorization', () => {
// The row was claimed once; a duplicate callback finds nothing left to redeem.
expect(await stores.tokenStore.consumePendingAuthorization({ state })).toBeUndefined();
- const saved = await stores.tokenStore.getToken({ id: SERVER_ID });
+ const saved = await stores.tokenStore.getToken({ id: SERVER_ID, userRef: USER_REF });
expect(saved?.accessToken).toBe('exchanged-access');
expect(saved?.refreshToken).toBe('exchanged-refresh');
const expiresAtMs = Date.parse(saved!.expiresAt);
@@ -669,6 +703,7 @@ describe('completeMcpAuthorization', () => {
pending: {
state: 'state-1',
id: SERVER_ID,
+ userRef: USER_REF,
mcpServerUrl: SERVER_URL,
codeVerifier: 'verifier-1',
redirectUrl: null,
@@ -724,10 +759,10 @@ describe('completeMcpAuthorization', () => {
message: expect.stringContaining('registration is invalid'),
});
expect(withTransactionCalls).toBe(1);
- expect(deleteToken).toHaveBeenCalledWith({ id: SERVER_ID }, transaction);
+ expect(deleteToken).toHaveBeenCalledWith({ id: SERVER_ID, userRef: USER_REF }, transaction);
expect(deleteClient).toHaveBeenCalledWith({ id: SERVER_ID }, transaction);
expect(await stores.mcpServerStore.getClient({ id: SERVER_ID })).toBeUndefined();
- expect(await stores.tokenStore.getToken({ id: SERVER_ID })).toBeUndefined();
+ expect(await stores.tokenStore.getToken({ id: SERVER_ID, userRef: USER_REF })).toBeUndefined();
});
});
diff --git a/packages/server/tests/unit/runtime/getMcpConnection.test.ts b/packages/server/tests/unit/runtime/getMcpConnection.test.ts
index 1cf253bf7..ee6831606 100644
--- a/packages/server/tests/unit/runtime/getMcpConnection.test.ts
+++ b/packages/server/tests/unit/runtime/getMcpConnection.test.ts
@@ -1,4 +1,5 @@
import { TENANT_ID } from '../../../src/apis/sessions';
+import { LOCAL_USER_CONTEXT } from '../../../src/auth/identity';
import { migrateSqliteToLatest } from '../../../src/db/migrateSqlite';
import { createSqliteDb } from '../../../src/db/sqlite/client';
import { SqliteMcpServerStore } from '../../../src/db/sqlite/mcp-server-store/SqliteMcpServerStore';
@@ -77,6 +78,7 @@ describe('getMcpConnection', () => {
store: mcpServerStore,
tokenStore,
clientName: 'test-client',
+ userRef: LOCAL_USER_CONTEXT.userRef,
});
expect(connection).toBeDefined();
if (connection === undefined) {
@@ -120,6 +122,7 @@ describe('getMcpConnection', () => {
});
await tokenStore.saveToken({
id: record.id,
+ userRef: LOCAL_USER_CONTEXT.userRef,
token: {
accessToken: 'live-access',
refreshToken: null,
@@ -134,6 +137,7 @@ describe('getMcpConnection', () => {
store: mcpServerStore,
tokenStore,
clientName: 'test-client',
+ userRef: LOCAL_USER_CONTEXT.userRef,
});
expect(connection).toBeDefined();
if (connection === undefined || typeof connection.headers !== 'function') {
@@ -161,6 +165,7 @@ describe('getMcpConnection', () => {
store: mcpServerStore,
tokenStore,
clientName: 'test-client',
+ userRef: LOCAL_USER_CONTEXT.userRef,
});
expect(connection).toBeDefined();
if (connection === undefined) {
@@ -189,6 +194,7 @@ describe('getMcpConnection', () => {
store: mcpServerStore,
tokenStore,
clientName: 'test-client',
+ userRef: LOCAL_USER_CONTEXT.userRef,
});
expect(connection).toBeDefined();
if (connection === undefined) {
@@ -207,6 +213,7 @@ describe('getMcpConnection', () => {
store: mcpServerStore,
tokenStore,
clientName: 'test-client',
+ userRef: LOCAL_USER_CONTEXT.userRef,
}),
).resolves.toBeUndefined();
});