integrate-sdk 0.6.5 → 0.6.6

package/dist/adapters/nextjs.js

@@ -0,0 +1,405 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/oauth/pkce.ts
+var exports_pkce = {};
+__export(exports_pkce, {
+  parseState: () => parseState,
+  generateStateWithReturnUrl: () => generateStateWithReturnUrl,
+  generateState: () => generateState,
+  generateCodeVerifier: () => generateCodeVerifier,
+  generateCodeChallenge: () => generateCodeChallenge
+});
+function generateCodeVerifier() {
+  const array = new Uint8Array(32);
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    crypto.getRandomValues(array);
+  } else if (typeof globalThis !== "undefined" && globalThis.crypto) {
+    globalThis.crypto.getRandomValues(array);
+  } else {
+    throw new Error("crypto.getRandomValues is not available. Please use Node.js 19+ or a modern browser.");
+  }
+  return base64UrlEncode(array);
+}
+async function generateCodeChallenge(verifier) {
+  const encoder = new TextEncoder;
+  const data = encoder.encode(verifier);
+  let hashBuffer;
+  if (typeof crypto !== "undefined" && crypto.subtle) {
+    hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  } else if (typeof globalThis !== "undefined" && globalThis.crypto?.subtle) {
+    hashBuffer = await globalThis.crypto.subtle.digest("SHA-256", data);
+  } else {
+    throw new Error("crypto.subtle.digest is not available. Please use Node.js 19+ or a modern browser.");
+  }
+  return base64UrlEncode(new Uint8Array(hashBuffer));
+}
+function generateState() {
+  const array = new Uint8Array(16);
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    crypto.getRandomValues(array);
+  } else if (typeof globalThis !== "undefined" && globalThis.crypto) {
+    globalThis.crypto.getRandomValues(array);
+  } else {
+    throw new Error("crypto.getRandomValues is not available. Please use Node.js 19+ or a modern browser.");
+  }
+  return base64UrlEncode(array);
+}
+function generateStateWithReturnUrl(returnUrl) {
+  const csrf = generateState();
+  const stateData = returnUrl ? { csrf, returnUrl } : { csrf };
+  const encoder = new TextEncoder;
+  const jsonBytes = encoder.encode(JSON.stringify(stateData));
+  return base64UrlEncode(jsonBytes);
+}
+function parseState(state) {
+  try {
+    const decoded = base64UrlDecode(state);
+    const parsed = JSON.parse(decoded);
+    if (typeof parsed === "string") {
+      return { csrf: parsed };
+    } else if (parsed && typeof parsed === "object") {
+      return {
+        csrf: parsed.csrf || state,
+        returnUrl: parsed.returnUrl
+      };
+    }
+    return { csrf: state };
+  } catch {
+    return { csrf: state };
+  }
+}
+function base64UrlEncode(array) {
+  let base64 = "";
+  if (typeof Buffer !== "undefined") {
+    base64 = Buffer.from(array).toString("base64");
+  } else {
+    const binary = String.fromCharCode(...array);
+    base64 = btoa(binary);
+  }
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function base64UrlDecode(str) {
+  let base64 = str.replace(/-/g, "+").replace(/_/g, "/");
+  while (base64.length % 4 !== 0) {
+    base64 += "=";
+  }
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(base64, "base64").toString("utf-8");
+  } else {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0;i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    const decoder = new TextDecoder;
+    return decoder.decode(bytes);
+  }
+}
+
+// src/adapters/base-handler.ts
+var MCP_SERVER_URL = "https://mcp.integrate.dev/api/v1/mcp";
+
+class OAuthHandler {
+  config;
+  serverUrl;
+  apiKey;
+  constructor(config) {
+    this.config = config;
+    if (!config || !config.providers) {
+      throw new Error("OAuthHandler requires a valid config with providers");
+    }
+    this.serverUrl = config.serverUrl || MCP_SERVER_URL;
+    this.apiKey = config.apiKey;
+  }
+  getHeaders(additionalHeaders) {
+    const headers = {
+      ...additionalHeaders
+    };
+    if (this.apiKey) {
+      headers["X-API-KEY"] = this.apiKey;
+    }
+    return headers;
+  }
+  async handleAuthorize(request) {
+    const providerConfig = this.config.providers[request.provider];
+    if (!providerConfig) {
+      throw new Error(`Provider ${request.provider} not configured. Add OAuth credentials to your API route configuration.`);
+    }
+    if (!providerConfig.clientId || !providerConfig.clientSecret) {
+      throw new Error(`Missing OAuth credentials for ${request.provider}. Check your environment variables.`);
+    }
+    const url = new URL("/oauth/authorize", this.serverUrl);
+    url.searchParams.set("provider", request.provider);
+    url.searchParams.set("client_id", providerConfig.clientId);
+    url.searchParams.set("client_secret", providerConfig.clientSecret);
+    url.searchParams.set("scope", request.scopes.join(","));
+    url.searchParams.set("state", request.state);
+    url.searchParams.set("code_challenge", request.codeChallenge);
+    url.searchParams.set("code_challenge_method", request.codeChallengeMethod);
+    const redirectUri = request.redirectUri || providerConfig.redirectUri;
+    if (redirectUri) {
+      url.searchParams.set("redirect_uri", redirectUri);
+    }
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers: this.getHeaders()
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`MCP server failed to generate authorization URL: ${error}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+  async handleCallback(request) {
+    const providerConfig = this.config.providers[request.provider];
+    if (!providerConfig) {
+      throw new Error(`Provider ${request.provider} not configured. Add OAuth credentials to your API route configuration.`);
+    }
+    if (!providerConfig.clientId || !providerConfig.clientSecret) {
+      throw new Error(`Missing OAuth credentials for ${request.provider}. Check your environment variables.`);
+    }
+    const url = new URL("/oauth/callback", this.serverUrl);
+    const response = await fetch(url.toString(), {
+      method: "POST",
+      headers: this.getHeaders({
+        "Content-Type": "application/json"
+      }),
+      body: JSON.stringify({
+        provider: request.provider,
+        code: request.code,
+        code_verifier: request.codeVerifier,
+        state: request.state,
+        client_id: providerConfig.clientId,
+        client_secret: providerConfig.clientSecret,
+        redirect_uri: providerConfig.redirectUri
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`MCP server failed to exchange authorization code: ${error}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+  async handleStatus(provider, accessToken) {
+    const url = new URL("/oauth/status", this.serverUrl);
+    url.searchParams.set("provider", provider);
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers: this.getHeaders({
+        Authorization: `Bearer ${accessToken}`
+      })
+    });
+    if (!response.ok) {
+      if (response.status === 401) {
+        return {
+          authorized: false
+        };
+      }
+      const error = await response.text();
+      throw new Error(`MCP server failed to check authorization status: ${error}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+  async handleDisconnect(request, accessToken) {
+    if (!accessToken) {
+      throw new Error("No access token provided. Cannot disconnect provider.");
+    }
+    const url = new URL("/oauth/disconnect", this.serverUrl);
+    const response = await fetch(url.toString(), {
+      method: "POST",
+      headers: this.getHeaders({
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${accessToken}`
+      }),
+      body: JSON.stringify({
+        provider: request.provider
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`MCP server failed to disconnect provider: ${error}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+}
+
+// src/adapters/nextjs.ts
+function createNextOAuthHandler(config) {
+  const handler = new OAuthHandler(config);
+  const handlers = {
+    async authorize(req) {
+      try {
+        const body = await req.json();
+        const result = await handler.handleAuthorize(body);
+        return Response.json(result);
+      } catch (error) {
+        console.error("[OAuth Authorize] Error:", error);
+        return Response.json({ error: error.message || "Failed to get authorization URL" }, { status: 500 });
+      }
+    },
+    async callback(req) {
+      try {
+        const body = await req.json();
+        const result = await handler.handleCallback(body);
+        return Response.json(result);
+      } catch (error) {
+        console.error("[OAuth Callback] Error:", error);
+        return Response.json({ error: error.message || "Failed to exchange authorization code" }, { status: 500 });
+      }
+    },
+    async status(req) {
+      try {
+        const provider = req.nextUrl.searchParams.get("provider");
+        const authHeader = req.headers.get("authorization");
+        if (!provider) {
+          return Response.json({ error: "Missing provider query parameter" }, { status: 400 });
+        }
+        if (!authHeader || !authHeader.startsWith("Bearer ")) {
+          return Response.json({ error: "Missing or invalid Authorization header" }, { status: 400 });
+        }
+        const accessToken = authHeader.substring(7);
+        const result = await handler.handleStatus(provider, accessToken);
+        return Response.json(result);
+      } catch (error) {
+        console.error("[OAuth Status] Error:", error);
+        return Response.json({ error: error.message || "Failed to check authorization status" }, { status: 500 });
+      }
+    },
+    async disconnect(req) {
+      try {
+        const authHeader = req.headers.get("authorization");
+        if (!authHeader || !authHeader.startsWith("Bearer ")) {
+          return Response.json({ error: "Missing or invalid Authorization header" }, { status: 400 });
+        }
+        const accessToken = authHeader.substring(7);
+        const body = await req.json();
+        const { provider } = body;
+        if (!provider) {
+          return Response.json({ error: "Missing provider in request body" }, { status: 400 });
+        }
+        const result = await handler.handleDisconnect({ provider }, accessToken);
+        return Response.json(result);
+      } catch (error) {
+        console.error("[OAuth Disconnect] Error:", error);
+        return Response.json({ error: error.message || "Failed to disconnect provider" }, { status: 500 });
+      }
+    },
+    createRoutes() {
+      return {
+        async POST(req, context) {
+          const params = context.params instanceof Promise ? await context.params : context.params;
+          const action = params.action;
+          if (action === "authorize") {
+            return handlers.authorize(req);
+          }
+          if (action === "callback") {
+            return handlers.callback(req);
+          }
+          if (action === "disconnect") {
+            return handlers.disconnect(req);
+          }
+          return Response.json({ error: `Unknown action: ${action}` }, { status: 404 });
+        },
+        async GET(req, context) {
+          const params = context.params instanceof Promise ? await context.params : context.params;
+          const action = params.action;
+          if (action === "status") {
+            return handlers.status(req);
+          }
+          return Response.json({ error: `Unknown action: ${action}` }, { status: 404 });
+        }
+      };
+    },
+    toNextJsHandler(redirectConfig) {
+      const defaultRedirectUrl = redirectConfig?.redirectUrl || "/";
+      const errorRedirectUrl = redirectConfig?.errorRedirectUrl || "/auth-error";
+      return {
+        async POST(req, context) {
+          const params = context.params instanceof Promise ? await context.params : context.params;
+          const segments = params.all || [];
+          if (segments.length === 2 && segments[0] === "oauth") {
+            const action = segments[1];
+            if (action === "authorize") {
+              return handlers.authorize(req);
+            }
+            if (action === "callback") {
+              return handlers.callback(req);
+            }
+            if (action === "disconnect") {
+              return handlers.disconnect(req);
+            }
+            return Response.json({ error: `Unknown action: ${action}` }, { status: 404 });
+          }
+          return Response.json({ error: `Invalid route: /${segments.join("/")}` }, { status: 404 });
+        },
+        async GET(req, context) {
+          const params = context.params instanceof Promise ? await context.params : context.params;
+          const segments = params.all || [];
+          if (segments.length === 2 && segments[0] === "oauth") {
+            const action = segments[1];
+            if (action === "status") {
+              return handlers.status(req);
+            }
+            if (action === "callback") {
+              const { searchParams } = new URL(req.url);
+              const code = searchParams.get("code");
+              const state = searchParams.get("state");
+              const error = searchParams.get("error");
+              const errorDescription = searchParams.get("error_description");
+              if (error) {
+                const errorMsg = errorDescription || error;
+                console.error("[OAuth Redirect] Error:", errorMsg);
+                return Response.redirect(new URL(`${errorRedirectUrl}?error=${encodeURIComponent(errorMsg)}`, req.url));
+              }
+              if (!code || !state) {
+                console.error("[OAuth Redirect] Missing code or state parameter");
+                return Response.redirect(new URL(`${errorRedirectUrl}?error=${encodeURIComponent("Invalid OAuth callback")}`, req.url));
+              }
+              let returnUrl = defaultRedirectUrl;
+              try {
+                const { parseState: parseState2 } = await Promise.resolve().then(() => exports_pkce);
+                const stateData = parseState2(state);
+                if (stateData.returnUrl) {
+                  returnUrl = stateData.returnUrl;
+                }
+              } catch (e) {
+                try {
+                  const referrer = req.headers?.get?.("referer") || req.headers?.get?.("referrer");
+                  if (referrer) {
+                    const referrerUrl = new URL(referrer);
+                    const currentUrl = new URL(req.url);
+                    if (referrerUrl.origin === currentUrl.origin) {
+                      returnUrl = referrerUrl.pathname + referrerUrl.search;
+                    }
+                  }
+                } catch {}
+              }
+              const targetUrl = new URL(returnUrl, req.url);
+              targetUrl.hash = `oauth_callback=${encodeURIComponent(JSON.stringify({ code, state }))}`;
+              return Response.redirect(targetUrl);
+            }
+            return Response.json({ error: `Unknown action: ${action}` }, { status: 404 });
+          }
+          return Response.json({ error: `Invalid route: /${segments.join("/")}` }, { status: 404 });
+        }
+      };
+    }
+  };
+  return handlers;
+}
+export {
+  createNextOAuthHandler
+};

package/dist/adapters/node.js

@@ -0,0 +1,280 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/adapters/base-handler.ts
+var MCP_SERVER_URL = "https://mcp.integrate.dev/api/v1/mcp";
+
+class OAuthHandler {
+  config;
+  serverUrl;
+  apiKey;
+  constructor(config) {
+    this.config = config;
+    if (!config || !config.providers) {
+      throw new Error("OAuthHandler requires a valid config with providers");
+    }
+    this.serverUrl = config.serverUrl || MCP_SERVER_URL;
+    this.apiKey = config.apiKey;
+  }
+  getHeaders(additionalHeaders) {
+    const headers = {
+      ...additionalHeaders
+    };
+    if (this.apiKey) {
+      headers["X-API-KEY"] = this.apiKey;
+    }
+    return headers;
+  }
+  async handleAuthorize(request) {
+    const providerConfig = this.config.providers[request.provider];
+    if (!providerConfig) {
+      throw new Error(`Provider ${request.provider} not configured. Add OAuth credentials to your API route configuration.`);
+    }
+    if (!providerConfig.clientId || !providerConfig.clientSecret) {
+      throw new Error(`Missing OAuth credentials for ${request.provider}. Check your environment variables.`);
+    }
+    const url = new URL("/oauth/authorize", this.serverUrl);
+    url.searchParams.set("provider", request.provider);
+    url.searchParams.set("client_id", providerConfig.clientId);
+    url.searchParams.set("client_secret", providerConfig.clientSecret);
+    url.searchParams.set("scope", request.scopes.join(","));
+    url.searchParams.set("state", request.state);
+    url.searchParams.set("code_challenge", request.codeChallenge);
+    url.searchParams.set("code_challenge_method", request.codeChallengeMethod);
+    const redirectUri = request.redirectUri || providerConfig.redirectUri;
+    if (redirectUri) {
+      url.searchParams.set("redirect_uri", redirectUri);
+    }
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers: this.getHeaders()
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`MCP server failed to generate authorization URL: ${error}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+  async handleCallback(request) {
+    const providerConfig = this.config.providers[request.provider];
+    if (!providerConfig) {
+      throw new Error(`Provider ${request.provider} not configured. Add OAuth credentials to your API route configuration.`);
+    }
+    if (!providerConfig.clientId || !providerConfig.clientSecret) {
+      throw new Error(`Missing OAuth credentials for ${request.provider}. Check your environment variables.`);
+    }
+    const url = new URL("/oauth/callback", this.serverUrl);
+    const response = await fetch(url.toString(), {
+      method: "POST",
+      headers: this.getHeaders({
+        "Content-Type": "application/json"
+      }),
+      body: JSON.stringify({
+        provider: request.provider,
+        code: request.code,
+        code_verifier: request.codeVerifier,
+        state: request.state,
+        client_id: providerConfig.clientId,
+        client_secret: providerConfig.clientSecret,
+        redirect_uri: providerConfig.redirectUri
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`MCP server failed to exchange authorization code: ${error}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+  async handleStatus(provider, accessToken) {
+    const url = new URL("/oauth/status", this.serverUrl);
+    url.searchParams.set("provider", provider);
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers: this.getHeaders({
+        Authorization: `Bearer ${accessToken}`
+      })
+    });
+    if (!response.ok) {
+      if (response.status === 401) {
+        return {
+          authorized: false
+        };
+      }
+      const error = await response.text();
+      throw new Error(`MCP server failed to check authorization status: ${error}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+  async handleDisconnect(request, accessToken) {
+    if (!accessToken) {
+      throw new Error("No access token provided. Cannot disconnect provider.");
+    }
+    const url = new URL("/oauth/disconnect", this.serverUrl);
+    const response = await fetch(url.toString(), {
+      method: "POST",
+      headers: this.getHeaders({
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${accessToken}`
+      }),
+      body: JSON.stringify({
+        provider: request.provider
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`MCP server failed to disconnect provider: ${error}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+}
+
+// src/adapters/node.ts
+function fromNodeHeaders(nodeHeaders) {
+  const webHeaders = new Headers;
+  for (const [key, value] of Object.entries(nodeHeaders)) {
+    if (value !== undefined) {
+      if (Array.isArray(value)) {
+        value.forEach((v) => webHeaders.append(key, v));
+      } else {
+        webHeaders.set(key, value);
+      }
+    }
+  }
+  return webHeaders;
+}
+async function toWebRequest(req) {
+  const protocol = req.socket.encrypted ? "https" : "http";
+  const host = req.headers.host || "localhost";
+  const url = `${protocol}://${host}${req.url}`;
+  const headers = fromNodeHeaders(req.headers);
+  let body;
+  if (req.method && ["POST", "PUT", "PATCH"].includes(req.method)) {
+    body = await new Promise((resolve, reject) => {
+      let data = "";
+      req.on("data", (chunk) => data += chunk);
+      req.on("end", () => resolve(data));
+      req.on("error", reject);
+    });
+  }
+  return new Request(url, {
+    method: req.method,
+    headers,
+    body: body || undefined
+  });
+}
+async function sendWebResponse(webRes, nodeRes) {
+  nodeRes.statusCode = webRes.status;
+  webRes.headers.forEach((value, key) => {
+    nodeRes.setHeader(key, value);
+  });
+  const body = await webRes.text();
+  nodeRes.end(body);
+}
+function toNodeHandler(config) {
+  const oauthHandler = new OAuthHandler(config);
+  return async (req, res) => {
+    try {
+      const webReq = await toWebRequest(req);
+      const url = new URL(webReq.url);
+      const segments = url.pathname.split("/").filter(Boolean);
+      const action = segments[segments.length - 1];
+      let webRes;
+      if (req.method === "POST") {
+        if (action === "authorize") {
+          const body = await webReq.json();
+          const result = await oauthHandler.handleAuthorize(body);
+          webRes = new Response(JSON.stringify(result), {
+            status: 200,
+            headers: { "Content-Type": "application/json" }
+          });
+        } else if (action === "callback") {
+          const body = await webReq.json();
+          const result = await oauthHandler.handleCallback(body);
+          webRes = new Response(JSON.stringify(result), {
+            status: 200,
+            headers: { "Content-Type": "application/json" }
+          });
+        } else if (action === "disconnect") {
+          const authHeader = webReq.headers.get("authorization");
+          if (!authHeader || !authHeader.startsWith("Bearer ")) {
+            webRes = new Response(JSON.stringify({ error: "Missing or invalid Authorization header" }), {
+              status: 400,
+              headers: { "Content-Type": "application/json" }
+            });
+          } else {
+            const accessToken = authHeader.substring(7);
+            const body = await webReq.json();
+            const { provider } = body;
+            if (!provider) {
+              webRes = new Response(JSON.stringify({ error: "Missing provider in request body" }), {
+                status: 400,
+                headers: { "Content-Type": "application/json" }
+              });
+            } else {
+              const result = await oauthHandler.handleDisconnect({ provider }, accessToken);
+              webRes = new Response(JSON.stringify(result), {
+                status: 200,
+                headers: { "Content-Type": "application/json" }
+              });
+            }
+          }
+        } else {
+          webRes = new Response(JSON.stringify({ error: `Unknown action: ${action}` }), {
+            status: 404,
+            headers: { "Content-Type": "application/json" }
+          });
+        }
+      } else if (req.method === "GET" && action === "status") {
+        const provider = url.searchParams.get("provider");
+        const authHeader = webReq.headers.get("authorization");
+        if (!provider) {
+          webRes = new Response(JSON.stringify({ error: "Missing provider query parameter" }), {
+            status: 400,
+            headers: { "Content-Type": "application/json" }
+          });
+        } else if (!authHeader || !authHeader.startsWith("Bearer ")) {
+          webRes = new Response(JSON.stringify({ error: "Missing or invalid Authorization header" }), {
+            status: 400,
+            headers: { "Content-Type": "application/json" }
+          });
+        } else {
+          const accessToken = authHeader.substring(7);
+          const result = await oauthHandler.handleStatus(provider, accessToken);
+          webRes = new Response(JSON.stringify(result), {
+            status: 200,
+            headers: { "Content-Type": "application/json" }
+          });
+        }
+      } else {
+        webRes = new Response(JSON.stringify({ error: `Unknown action: ${action}` }), {
+          status: 404,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+      await sendWebResponse(webRes, res);
+    } catch (error) {
+      console.error("[OAuth Handler] Error:", error);
+      const errorRes = new Response(JSON.stringify({ error: error.message || "Internal server error" }), {
+        status: 500,
+        headers: { "Content-Type": "application/json" }
+      });
+      await sendWebResponse(errorRes, res);
+    }
+  };
+}
+export {
+  toNodeHandler,
+  fromNodeHeaders
+};