@wincode/mcp 0.0.0-stage → 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/src/oauth.ts ADDED
@@ -0,0 +1,347 @@
1
+ import {
2
+ auth,
3
+ type OAuthClientInformationContext,
4
+ type OAuthClientMetadata,
5
+ type OAuthClientProvider,
6
+ type OAuthDiscoveryState,
7
+ type StoredOAuthClientInformation,
8
+ type StoredOAuthTokens,
9
+ } from "@modelcontextprotocol/client";
10
+ import { isPlainObject } from "@wincode/utils";
11
+
12
+ export type McpSecretStore = Readonly<{
13
+ delete: (key: string) => Promise<void>;
14
+ get: (key: string) => Promise<string | undefined>;
15
+ set: (key: string, value: string) => Promise<void>;
16
+ }>;
17
+
18
+ const hashIdentifier = (value: string): string =>
19
+ new Bun.CryptoHasher("sha256").update(value).digest("hex");
20
+ const secretPrefix = (serverName: string): string => {
21
+ const prefix = `mcp.oauth.${serverName}`;
22
+ if (prefix.length <= 52) {
23
+ return prefix;
24
+ }
25
+ return `mcp.oauth.${hashIdentifier(serverName).slice(0, 32)}`;
26
+ };
27
+ const activeIssuerKey = (serverName: string): string =>
28
+ `${secretPrefix(serverName)}.active-issuer`;
29
+ const issuerKey = (serverName: string, issuer: string): string =>
30
+ `${secretPrefix(serverName)}.${hashIdentifier(issuer)}`;
31
+ const flowKey = (serverName: string, name: string): string =>
32
+ `${secretPrefix(serverName)}.flow.${name}`;
33
+
34
+ const deleteIssuerCredential = async (
35
+ secrets: McpSecretStore,
36
+ serverName: string,
37
+ credential: "client" | "tokens" | "discovery"
38
+ ): Promise<void> => {
39
+ const issuer = await secrets.get(activeIssuerKey(serverName));
40
+ if (issuer !== undefined) {
41
+ await secrets.delete(`${issuerKey(serverName, issuer)}.${credential}`);
42
+ }
43
+ };
44
+
45
+ const parseSecret = async <Value>(
46
+ secrets: McpSecretStore,
47
+ key: string,
48
+ isValue: (value: unknown) => value is Value
49
+ ): Promise<Value | undefined> => {
50
+ const stored = await secrets.get(key);
51
+ if (stored === undefined) {
52
+ return;
53
+ }
54
+ try {
55
+ const value: unknown = JSON.parse(stored);
56
+ return isValue(value) ? value : undefined;
57
+ } catch {
58
+ return;
59
+ }
60
+ };
61
+
62
+ const hasAccessToken = (value: unknown): value is StoredOAuthTokens =>
63
+ isPlainObject(value) &&
64
+ typeof value.access_token === "string" &&
65
+ typeof value.token_type === "string";
66
+
67
+ const hasClientInformation = (
68
+ value: unknown
69
+ ): value is StoredOAuthClientInformation =>
70
+ isPlainObject(value) && typeof value.client_id === "string";
71
+
72
+ const hasDiscoveryState = (value: unknown): value is OAuthDiscoveryState =>
73
+ isPlainObject(value) && typeof value.authorizationServerUrl === "string";
74
+
75
+ const oauthConfig = (value: unknown): Readonly<Record<string, unknown>> =>
76
+ isPlainObject(value) ? value : {};
77
+
78
+ export type McpOAuthProviderInput = Readonly<{
79
+ onAuthorizationUrl?: (url: URL) => void | Promise<void>;
80
+ oauth?: unknown;
81
+ redirectUrl?: string;
82
+ secrets: McpSecretStore;
83
+ serverName: string;
84
+ }>;
85
+
86
+ export type McpOAuthClientProvider = OAuthClientProvider &
87
+ Readonly<{ getCurrentState: () => string | undefined }>;
88
+
89
+ export const createMcpOAuthProvider = ({
90
+ onAuthorizationUrl,
91
+ oauth: oauthValue,
92
+ redirectUrl,
93
+ secrets,
94
+ serverName,
95
+ }: McpOAuthProviderInput): McpOAuthClientProvider => {
96
+ const oauth = oauthConfig(oauthValue);
97
+ if (Object.hasOwn(oauth, "clientSecret")) {
98
+ throw new Error(
99
+ "MCP OAuth client secrets must be stored through the host secret store."
100
+ );
101
+ }
102
+ const configuredClientId =
103
+ typeof oauth.clientId === "string" ? oauth.clientId : undefined;
104
+ const metadata: OAuthClientMetadata = {
105
+ client_name:
106
+ typeof oauth.clientName === "string" ? oauth.clientName : "Wincode",
107
+ redirect_uris: redirectUrl === undefined ? [] : [redirectUrl],
108
+ token_endpoint_auth_method: "none",
109
+ };
110
+ let currentState: string | undefined;
111
+ return {
112
+ get clientMetadata() {
113
+ return metadata;
114
+ },
115
+ get redirectUrl() {
116
+ return redirectUrl;
117
+ },
118
+ async clientInformation(context?: OAuthClientInformationContext) {
119
+ const issuer =
120
+ context?.issuer ?? (await secrets.get(activeIssuerKey(serverName)));
121
+ if (issuer !== undefined) {
122
+ const stored = await parseSecret(
123
+ secrets,
124
+ `${issuerKey(serverName, issuer)}.client`,
125
+ hasClientInformation
126
+ );
127
+ if (stored !== undefined) {
128
+ return stored;
129
+ }
130
+ }
131
+ if (configuredClientId === undefined) {
132
+ return;
133
+ }
134
+ return { client_id: configuredClientId } as StoredOAuthClientInformation;
135
+ },
136
+ async saveClientInformation(information, context) {
137
+ const issuer = context?.issuer ?? information.issuer;
138
+ if (issuer === undefined) {
139
+ throw new Error("OAuth client registration did not include an issuer.");
140
+ }
141
+ await secrets.set(
142
+ `${issuerKey(serverName, issuer)}.client`,
143
+ JSON.stringify(information)
144
+ );
145
+ await secrets.set(activeIssuerKey(serverName), issuer);
146
+ },
147
+ async tokens(context) {
148
+ const issuer =
149
+ context?.issuer ?? (await secrets.get(activeIssuerKey(serverName)));
150
+ if (issuer === undefined) {
151
+ return;
152
+ }
153
+ return await parseSecret(
154
+ secrets,
155
+ `${issuerKey(serverName, issuer)}.tokens`,
156
+ hasAccessToken
157
+ );
158
+ },
159
+ async saveTokens(tokens, context) {
160
+ const issuer = context?.issuer ?? tokens.issuer;
161
+ if (issuer === undefined) {
162
+ throw new Error("OAuth tokens did not include an issuer.");
163
+ }
164
+ await secrets.set(
165
+ `${issuerKey(serverName, issuer)}.tokens`,
166
+ JSON.stringify(tokens)
167
+ );
168
+ await secrets.set(activeIssuerKey(serverName), issuer);
169
+ },
170
+ async state() {
171
+ currentState ??= await secrets.get(flowKey(serverName, "state"));
172
+ if (currentState === undefined) {
173
+ currentState = crypto.randomUUID();
174
+ await secrets.set(flowKey(serverName, "state"), currentState);
175
+ }
176
+ return currentState;
177
+ },
178
+ async saveCodeVerifier(verifier) {
179
+ await secrets.set(flowKey(serverName, "verifier"), verifier);
180
+ },
181
+ async codeVerifier() {
182
+ const verifier = await secrets.get(flowKey(serverName, "verifier"));
183
+ if (verifier === undefined) {
184
+ throw new Error("OAuth PKCE verifier is unavailable.");
185
+ }
186
+ return verifier;
187
+ },
188
+ async redirectToAuthorization(url) {
189
+ await onAuthorizationUrl?.(url);
190
+ },
191
+ async saveDiscoveryState(state) {
192
+ await secrets.set(
193
+ `${issuerKey(serverName, state.authorizationServerUrl)}.discovery`,
194
+ JSON.stringify(state)
195
+ );
196
+ await secrets.set(
197
+ activeIssuerKey(serverName),
198
+ state.authorizationServerUrl
199
+ );
200
+ },
201
+ async discoveryState() {
202
+ const issuer = await secrets.get(activeIssuerKey(serverName));
203
+ if (issuer === undefined) {
204
+ return;
205
+ }
206
+ return await parseSecret(
207
+ secrets,
208
+ `${issuerKey(serverName, issuer)}.discovery`,
209
+ hasDiscoveryState
210
+ );
211
+ },
212
+ async invalidateCredentials(scope) {
213
+ if (scope === "all" || scope === "client") {
214
+ await deleteIssuerCredential(secrets, serverName, "client");
215
+ }
216
+ if (scope === "all" || scope === "tokens") {
217
+ await deleteIssuerCredential(secrets, serverName, "tokens");
218
+ }
219
+ if (scope === "all" || scope === "verifier") {
220
+ await secrets.delete(flowKey(serverName, "verifier"));
221
+ await secrets.delete(flowKey(serverName, "state"));
222
+ }
223
+ if (scope === "all" || scope === "discovery") {
224
+ await deleteIssuerCredential(secrets, serverName, "discovery");
225
+ }
226
+ if (scope === "all") {
227
+ await secrets.delete(activeIssuerKey(serverName));
228
+ }
229
+ },
230
+ getCurrentState: () => currentState,
231
+ };
232
+ };
233
+
234
+ export type McpOAuthLoginInput = Readonly<{
235
+ openAuthorizationUrl: (url: URL) => void | Promise<void>;
236
+ oauth?: unknown;
237
+ readRedirectUrl?: (callback: Promise<URL>) => Promise<URL>;
238
+ secrets: McpSecretStore;
239
+ serverName: string;
240
+ serverUrl: string;
241
+ }>;
242
+
243
+ type OAuthCallback = Readonly<{
244
+ promise: Promise<URL>;
245
+ reject: (reason?: unknown) => void;
246
+ resolve: (value: URL | PromiseLike<URL>) => void;
247
+ }>;
248
+
249
+ const createOAuthCallbackHandler =
250
+ (callback: OAuthCallback, getState: () => string | undefined) =>
251
+ (request: Request): Response => {
252
+ const url = new URL(request.url);
253
+ if (url.pathname !== "/oauth/callback") {
254
+ return new Response("Not found", { status: 404 });
255
+ }
256
+ const state = url.searchParams.get("state");
257
+ if (state === null || state !== getState()) {
258
+ return new Response("Invalid OAuth state", { status: 400 });
259
+ }
260
+ if (url.searchParams.has("error")) {
261
+ callback.reject(new Error("OAuth authorization was denied."));
262
+ return new Response("Authorization was denied. Return to Wincode.", {
263
+ status: 400,
264
+ });
265
+ }
266
+ if (!url.searchParams.has("code")) {
267
+ return new Response("Authorization code is missing", { status: 400 });
268
+ }
269
+ callback.resolve(url);
270
+ return new Response("Authorization complete. You can return to Wincode.", {
271
+ headers: { "content-type": "text/plain; charset=utf-8" },
272
+ });
273
+ };
274
+
275
+ const authorizationCodeFrom = (
276
+ response: URL,
277
+ expectedState: string | undefined
278
+ ): string => {
279
+ if (
280
+ expectedState === undefined ||
281
+ response.searchParams.get("state") !== expectedState
282
+ ) {
283
+ throw new Error("OAuth authorization response state did not match.");
284
+ }
285
+ const code = response.searchParams.get("code");
286
+ if (code === null || code.length === 0) {
287
+ throw new Error("OAuth authorization response did not include a code.");
288
+ }
289
+ return code;
290
+ };
291
+
292
+ export const loginMcpServer = async ({
293
+ openAuthorizationUrl,
294
+ oauth,
295
+ readRedirectUrl,
296
+ secrets,
297
+ serverName,
298
+ serverUrl,
299
+ }: McpOAuthLoginInput): Promise<void> => {
300
+ const callback = Promise.withResolvers<URL>();
301
+ let getState: () => string | undefined = () => undefined;
302
+ const server = Bun.serve({
303
+ fetch: createOAuthCallbackHandler(callback, () => getState()),
304
+ hostname: "127.0.0.1",
305
+ port: 0,
306
+ });
307
+ const redirectUrl = `http://127.0.0.1:${server.port}/oauth/callback`;
308
+ await secrets.delete(flowKey(serverName, "state"));
309
+ await secrets.delete(flowKey(serverName, "verifier"));
310
+ const provider = createMcpOAuthProvider({
311
+ onAuthorizationUrl: openAuthorizationUrl,
312
+ oauth,
313
+ redirectUrl,
314
+ secrets,
315
+ serverName,
316
+ });
317
+ getState = () => provider.getCurrentState();
318
+ try {
319
+ const firstResult = await auth(provider, { serverUrl });
320
+ if (firstResult === "AUTHORIZED") {
321
+ return;
322
+ }
323
+ const response = await (readRedirectUrl?.(callback.promise) ??
324
+ callback.promise);
325
+ const code = authorizationCodeFrom(response, provider.getCurrentState());
326
+ const result = await auth(provider, {
327
+ authorizationCode: code,
328
+ iss: response.searchParams.get("iss") ?? undefined,
329
+ serverUrl,
330
+ });
331
+ if (result !== "AUTHORIZED") {
332
+ throw new Error("OAuth authorization did not complete.");
333
+ }
334
+ await secrets.delete(flowKey(serverName, "state"));
335
+ await secrets.delete(flowKey(serverName, "verifier"));
336
+ } finally {
337
+ server.stop(true);
338
+ }
339
+ };
340
+
341
+ export const logoutMcpServer = async (
342
+ secrets: McpSecretStore,
343
+ serverName: string
344
+ ): Promise<void> => {
345
+ const provider = createMcpOAuthProvider({ secrets, serverName });
346
+ await provider.invalidateCredentials?.("all");
347
+ };
@@ -0,0 +1,40 @@
1
+ import type {
2
+ PluginConfigFileStore,
3
+ PluginMcpServerRegistration,
4
+ } from "@wincode/coding-agent";
5
+ import type { McpConfigLoader, McpConfigResult } from "../config";
6
+ import { resolveMcpConfig } from "../config";
7
+
8
+ export type {
9
+ InvalidMcpServerConfig,
10
+ McpConfigDiagnostic,
11
+ McpConfigResult,
12
+ ResolvedMcpServerConfig,
13
+ } from "../config";
14
+
15
+ /** Adapts MCP's configuration interpretation to the host's merged snapshot. */
16
+ export const createMcpConfigLoader =
17
+ (
18
+ configFiles: PluginConfigFileStore,
19
+ getMcpServerRegistrations: () => readonly PluginMcpServerRegistration[] = () => []
20
+ ): McpConfigLoader =>
21
+ async ({ env, refresh, workspace }): Promise<McpConfigResult> => {
22
+ const snapshot = await (refresh
23
+ ? configFiles.refreshSnapshot("mcp")
24
+ : configFiles.getSnapshot("mcp"));
25
+ const registrationSources = getMcpServerRegistrations().map(
26
+ ({ config, name, ownerPluginId }) => ({
27
+ document: { mcpServers: { [name]: config } },
28
+ path: `plugin:${ownerPluginId}`,
29
+ scope: "plugin",
30
+ })
31
+ );
32
+ return resolveMcpConfig({
33
+ env: { ...env },
34
+ snapshot: {
35
+ ...snapshot,
36
+ sources: [...registrationSources, ...snapshot.sources],
37
+ },
38
+ workspace,
39
+ });
40
+ };