integrate-sdk 0.6.5 → 0.6.6

package/dist/adapters/solid-start.js

@@ -0,0 +1,27 @@
+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/solid-start.ts
+function toSolidStartHandler(baseHandler) {
+  const handler = async (event) => {
+    return baseHandler(event.request);
+  };
+  return {
+    GET: handler,
+    POST: handler,
+    PATCH: handler,
+    PUT: handler,
+    DELETE: handler
+  };
+}
+export {
+  toSolidStartHandler
+};

package/dist/adapters/svelte-kit.js

@@ -0,0 +1,34 @@
+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/svelte-kit.ts
+async function svelteKitHandler({
+  authConfig,
+  event,
+  resolve,
+  basePath = "/api/auth"
+}) {
+  const { url } = event;
+  const baseUrl = new URL(basePath, url.origin);
+  if (!url.pathname.startsWith(baseUrl.pathname)) {
+    return resolve(event);
+  }
+  return authConfig(event.request);
+}
+function toSvelteKitHandler(baseHandler) {
+  return async (event) => {
+    return baseHandler(event.request);
+  };
+}
+export {
+  toSvelteKitHandler,
+  svelteKitHandler
+};

package/dist/adapters/tanstack-start.js

@@ -0,0 +1,26 @@
+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/tanstack-start.ts
+function toTanStackStartHandler(handler) {
+  const baseHandler = async ({ request }) => {
+    return handler(request);
+  };
+  return {
+    GET: baseHandler,
+    POST: baseHandler
+  };
+}
+var createTanStackOAuthHandler = toTanStackStartHandler;
+export {
+  toTanStackStartHandler,
+  createTanStackOAuthHandler
+};

package/dist/index.js

@@ -1891,90 +1891,183 @@ function createOAuthRedirectHandler(config) {
     return Response.redirect(targetUrl);
   };
 }
-// src/adapters/tanstack-start.ts
-function createTanStackOAuthHandler(config) {
-  const handler = new OAuthHandler(config);
-  return {
-    async authorize({ request }) {
-      try {
-        const body = await request.json();
-        const result = await handler.handleAuthorize(body);
-        return new Response(JSON.stringify(result), {
-          status: 200,
-          headers: {
-            "Content-Type": "application/json"
-          }
-        });
-      } catch (error) {
-        console.error("[OAuth Authorize] Error:", error);
-        return new Response(JSON.stringify({ error: error.message || "Failed to get authorization URL" }), {
-          status: 500,
-          headers: {
-            "Content-Type": "application/json"
-          }
-        });
+// 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);
       }
-    },
-    async callback({ request }) {
-      try {
-        const body = await request.json();
-        const result = await handler.handleCallback(body);
-        return new Response(JSON.stringify(result), {
-          status: 200,
-          headers: {
-            "Content-Type": "application/json"
-          }
-        });
-      } catch (error) {
-        console.error("[OAuth Callback] Error:", error);
-        return new Response(JSON.stringify({ error: error.message || "Failed to exchange authorization code" }), {
-          status: 500,
-          headers: {
-            "Content-Type": "application/json"
+    }
+  }
+  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" }
+              });
+            }
           }
-        });
-      }
-    },
-    async status({ request }) {
-      try {
-        const url = new URL(request.url);
+        } 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 sessionToken = request.headers.get("x-session-token");
+        const authHeader = webReq.headers.get("authorization");
         if (!provider) {
-          return new Response(JSON.stringify({ error: "Missing provider query parameter" }), {
+          webRes = new Response(JSON.stringify({ error: "Missing provider query parameter" }), {
             status: 400,
-            headers: {
-              "Content-Type": "application/json"
-            }
+            headers: { "Content-Type": "application/json" }
           });
-        }
-        if (!sessionToken) {
-          return new Response(JSON.stringify({ error: "Missing X-Session-Token header" }), {
+        } else if (!authHeader || !authHeader.startsWith("Bearer ")) {
+          webRes = new Response(JSON.stringify({ error: "Missing or invalid Authorization header" }), {
             status: 400,
-            headers: {
-              "Content-Type": "application/json"
-            }
+            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" }
           });
         }
-        const result = await handler.handleStatus(provider, sessionToken);
-        return new Response(JSON.stringify(result), {
-          status: 200,
-          headers: {
-            "Content-Type": "application/json"
-          }
-        });
-      } catch (error) {
-        console.error("[OAuth Status] Error:", error);
-        return new Response(JSON.stringify({ error: error.message || "Failed to check authorization status" }), {
-          status: 500,
-          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);
     }
   };
 }
+// src/adapters/solid-start.ts
+function toSolidStartHandler(baseHandler) {
+  const handler = async (event) => {
+    return baseHandler(event.request);
+  };
+  return {
+    GET: handler,
+    POST: handler,
+    PATCH: handler,
+    PUT: handler,
+    DELETE: handler
+  };
+}
+// src/adapters/svelte-kit.ts
+async function svelteKitHandler({
+  authConfig,
+  event,
+  resolve,
+  basePath = "/api/auth"
+}) {
+  const { url } = event;
+  const baseUrl = new URL(basePath, url.origin);
+  if (!url.pathname.startsWith(baseUrl.pathname)) {
+    return resolve(event);
+  }
+  return authConfig(event.request);
+}
+function toSvelteKitHandler(baseHandler) {
+  return async (event) => {
+    return baseHandler(event.request);
+  };
+}
+// src/adapters/tanstack-start.ts
+function toTanStackStartHandler(handler) {
+  const baseHandler = async ({ request }) => {
+    return handler(request);
+  };
+  return {
+    GET: baseHandler,
+    POST: baseHandler
+  };
+}
+var createTanStackOAuthHandler = toTanStackStartHandler;
 
 // src/index.ts
 init_errors();
@@ -6218,6 +6311,11 @@ async function getVercelAITools(client, options) {
   return convertMCPToolsToVercelAI(client, options);
 }
 export {
+  toTanStackStartHandler,
+  toSvelteKitHandler,
+  toSolidStartHandler,
+  toNodeHandler,
+  svelteKitHandler,
   sendCallbackToOpener,
   parseState,
   parseServerError,
@@ -6232,6 +6330,7 @@ export {
   generateState,
   generateCodeVerifier,
   generateCodeChallenge,
+  fromNodeHeaders,
   createTanStackOAuthHandler,
   createSimplePlugin,
   createOAuthRedirectHandler,

package/dist/src/adapters/node.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Node.js OAuth Route Adapter
+ * Provides OAuth route handlers for Node.js HTTP servers
+ */
+import { type OAuthHandlerConfig } from './base-handler.js';
+import type { IncomingHttpHeaders, IncomingMessage, ServerResponse } from 'http';
+/**
+ * Convert Node.js IncomingHttpHeaders to Web Headers
+ *
+ * @param nodeHeaders - Node.js request headers
+ * @returns Web API Headers object
+ */
+export declare function fromNodeHeaders(nodeHeaders: IncomingHttpHeaders): Headers;
+/**
+ * Create Node.js OAuth route handler
+ *
+ * Use this to create secure OAuth API routes in your Node.js HTTP server
+ * that handle authorization with server-side secrets.
+ *
+ * @param config - OAuth handler configuration with provider credentials
+ * @returns Request handler function for Node.js
+ *
+ * @example
+ * ```typescript
+ * import { createServer } from 'http';
+ * import { toNodeHandler } from 'integrate-sdk/adapters/node';
+ *
+ * const handler = toNodeHandler({
+ *   providers: {
+ *     github: {
+ *       clientId: process.env.GITHUB_CLIENT_ID!,
+ *       clientSecret: process.env.GITHUB_CLIENT_SECRET!,
+ *     },
+ *   },
+ * });
+ *
+ * createServer(async (req, res) => {
+ *   if (req.url?.startsWith('/api/auth/')) {
+ *     await handler(req, res);
+ *   } else {
+ *     res.statusCode = 404;
+ *     res.end('Not Found');
+ *   }
+ * }).listen(3000);
+ * ```
+ */
+export declare function toNodeHandler(config: OAuthHandlerConfig): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+//# sourceMappingURL=node.d.ts.map

package/dist/src/adapters/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/adapters/node.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAgB,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAC1E,OAAO,KAAK,EAAE,mBAAmB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAEjF;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,mBAAmB,GAAG,OAAO,CAYzE;AAkDD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,kBAAkB,IAGxC,KAAK,eAAe,EAAE,KAAK,cAAc,KAAG,OAAO,CAAC,IAAI,CAAC,CAsHxE"}

package/dist/src/adapters/solid-start.d.ts

@@ -0,0 +1,54 @@
+/**
+ * SolidStart OAuth Route Adapter
+ * Provides OAuth route handlers for SolidStart
+ */
+/**
+ * Create SolidStart OAuth route handlers
+ *
+ * Use this to create secure OAuth API routes in your SolidStart application
+ * that handle authorization with server-side secrets.
+ *
+ * @param baseHandler - Handler function from createMCPServer
+ * @returns Object with GET, POST, PATCH, PUT, DELETE handlers
+ *
+ * @example
+ * ```typescript
+ * // lib/integrate-server.ts
+ * import { createMCPServer, githubPlugin } from 'integrate-sdk/server';
+ *
+ * export const { client: serverClient, handler } = createMCPServer({
+ *   plugins: [
+ *     githubPlugin({
+ *       clientId: process.env.GITHUB_CLIENT_ID!,
+ *       clientSecret: process.env.GITHUB_CLIENT_SECRET!,
+ *     }),
+ *   ],
+ * });
+ *
+ * // src/routes/api/auth/[...all].ts
+ * import { toSolidStartHandler } from 'integrate-sdk/adapters/solid-start';
+ * import { handler } from '@/lib/integrate-server';
+ *
+ * const handlers = toSolidStartHandler(handler);
+ *
+ * export const { GET, POST, PATCH, PUT, DELETE } = handlers;
+ * ```
+ */
+export declare function toSolidStartHandler(baseHandler: (request: Request) => Promise<Response>): {
+    GET: (event: {
+        request: Request;
+    }) => Promise<Response>;
+    POST: (event: {
+        request: Request;
+    }) => Promise<Response>;
+    PATCH: (event: {
+        request: Request;
+    }) => Promise<Response>;
+    PUT: (event: {
+        request: Request;
+    }) => Promise<Response>;
+    DELETE: (event: {
+        request: Request;
+    }) => Promise<Response>;
+};
+//# sourceMappingURL=solid-start.d.ts.map

package/dist/src/adapters/solid-start.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solid-start.d.ts","sourceRoot":"","sources":["../../../src/adapters/solid-start.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC;iBACxD;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,KAAG,OAAO,CAAC,QAAQ,CAAC;kBAAxC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,KAAG,OAAO,CAAC,QAAQ,CAAC;mBAAxC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,KAAG,OAAO,CAAC,QAAQ,CAAC;iBAAxC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,KAAG,OAAO,CAAC,QAAQ,CAAC;oBAAxC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,KAAG,OAAO,CAAC,QAAQ,CAAC;EAWvE"}

package/dist/src/adapters/svelte-kit.d.ts

@@ -0,0 +1,82 @@
+/**
+ * SvelteKit OAuth Route Adapter
+ * Provides OAuth route handlers for SvelteKit
+ */
+type RequestEvent = any;
+type ResolveFunction = any;
+/**
+ * Create SvelteKit OAuth route handler for hooks
+ *
+ * Use this to integrate OAuth handling into your SvelteKit hooks.server.ts
+ *
+ * @param authConfig - Handler function from createMCPServer
+ * @param event - SvelteKit RequestEvent
+ * @param resolve - SvelteKit resolve function
+ * @param basePath - Base path for OAuth routes (default: '/api/auth')
+ * @returns Response from OAuth handler or resolved request
+ *
+ * @example
+ * ```typescript
+ * // lib/integrate-server.ts
+ * import { createMCPServer, githubPlugin } from 'integrate-sdk/server';
+ *
+ * export const { client: serverClient, handler } = createMCPServer({
+ *   plugins: [
+ *     githubPlugin({
+ *       clientId: process.env.GITHUB_CLIENT_ID!,
+ *       clientSecret: process.env.GITHUB_CLIENT_SECRET!,
+ *     }),
+ *   ],
+ * });
+ *
+ * // hooks.server.ts
+ * import { svelteKitHandler } from 'integrate-sdk/adapters/svelte-kit';
+ * import { handler } from '$lib/integrate-server';
+ *
+ * export async function handle({ event, resolve }) {
+ *   return svelteKitHandler({ authConfig: handler, event, resolve });
+ * }
+ * ```
+ */
+export declare function svelteKitHandler({ authConfig, event, resolve, basePath, }: {
+    authConfig: (request: Request) => Promise<Response>;
+    event: RequestEvent;
+    resolve: ResolveFunction;
+    basePath?: string;
+}): Promise<Response>;
+/**
+ * Create SvelteKit OAuth route handler
+ *
+ * Use this to create secure OAuth API routes in your SvelteKit application
+ * that handle authorization with server-side secrets.
+ *
+ * @param baseHandler - Handler function from createMCPServer
+ * @returns Handler function for SvelteKit routes
+ *
+ * @example
+ * ```typescript
+ * // lib/integrate-server.ts
+ * import { createMCPServer, githubPlugin } from 'integrate-sdk/server';
+ *
+ * export const { client: serverClient, handler } = createMCPServer({
+ *   plugins: [
+ *     githubPlugin({
+ *       clientId: process.env.GITHUB_CLIENT_ID!,
+ *       clientSecret: process.env.GITHUB_CLIENT_SECRET!,
+ *     }),
+ *   ],
+ * });
+ *
+ * // routes/api/auth/[...all]/+server.ts
+ * import { toSvelteKitHandler } from 'integrate-sdk/adapters/svelte-kit';
+ * import { handler } from '$lib/integrate-server';
+ *
+ * const svelteKitRoute = toSvelteKitHandler(handler);
+ *
+ * export const POST = svelteKitRoute;
+ * export const GET = svelteKitRoute;
+ * ```
+ */
+export declare function toSvelteKitHandler(baseHandler: (request: Request) => Promise<Response>): (event: RequestEvent) => Promise<Response>;
+export {};
+//# sourceMappingURL=svelte-kit.d.ts.map

package/dist/src/adapters/svelte-kit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"svelte-kit.d.ts","sourceRoot":"","sources":["../../../src/adapters/svelte-kit.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,KAAK,YAAY,GAAG,GAAG,CAAC;AACxB,KAAK,eAAe,GAAG,GAAG,CAAC;AAE3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAsB,gBAAgB,CAAC,EACnC,UAAU,EACV,KAAK,EACL,OAAO,EACP,QAAsB,GACzB,EAAE;IACC,UAAU,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;IACpD,KAAK,EAAE,YAAY,CAAC;IACpB,OAAO,EAAE,eAAe,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB,GAAG,OAAO,CAAC,QAAQ,CAAC,CAWpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,IACrE,OAAO,YAAY,KAAG,OAAO,CAAC,QAAQ,CAAC,CAGxD"}