integrate-sdk 0.8.31-dev.1 → 0.8.35

package/dist/adapters/svelte-kit.js

@@ -359,6 +359,81 @@ function methodToToolName(methodName, integrationId) {
   return `${integrationId}_${snakeCaseMethod}`;
 }
 
+// ../triggers/client.ts
+class TriggerClient {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async create(params) {
+    return this.request("POST", "/triggers", params);
+  }
+  async list(params) {
+    let path = "/triggers";
+    if (params) {
+      const searchParams = new URLSearchParams;
+      if (params.status)
+        searchParams.set("status", params.status);
+      if (params.toolName)
+        searchParams.set("toolName", params.toolName);
+      if (params.limit !== undefined)
+        searchParams.set("limit", params.limit.toString());
+      if (params.offset !== undefined)
+        searchParams.set("offset", params.offset.toString());
+      const query = searchParams.toString();
+      if (query)
+        path += `?${query}`;
+    }
+    return this.request("GET", path);
+  }
+  async get(triggerId) {
+    return this.request("GET", `/triggers/${triggerId}`);
+  }
+  async update(triggerId, params) {
+    return this.request("PATCH", `/triggers/${triggerId}`, params);
+  }
+  async delete(triggerId) {
+    await this.request("DELETE", `/triggers/${triggerId}`);
+  }
+  async pause(triggerId) {
+    return this.request("POST", `/triggers/${triggerId}/pause`);
+  }
+  async resume(triggerId) {
+    return this.request("POST", `/triggers/${triggerId}/resume`);
+  }
+  async run(triggerId) {
+    return this.request("POST", `/triggers/${triggerId}/run`);
+  }
+  async request(method, path, body) {
+    const url = this.config.apiBaseUrl ? `${this.config.apiBaseUrl}${this.config.apiRouteBase}${path}` : `${this.config.apiRouteBase}${path}`;
+    const options = {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        ...this.config.getHeaders()
+      }
+    };
+    if (body !== undefined) {
+      options.body = JSON.stringify(body);
+    }
+    const response = await fetch(url, options);
+    if (!response.ok) {
+      let errorMessage = `Request failed: ${response.statusText}`;
+      try {
+        const errorData = await response.json();
+        if (errorData.error) {
+          errorMessage = typeof errorData.error === "string" ? errorData.error : errorData.error.message || errorMessage;
+        }
+      } catch {}
+      throw new Error(errorMessage);
+    }
+    if (method === "DELETE" && response.status === 204) {
+      return;
+    }
+    return response.json();
+  }
+}
+
 // ../oauth/pkce.ts
 var exports_pkce = {};
 __export(exports_pkce, {
@@ -1537,6 +1612,7 @@ class MCPClientBase {
   databaseDetected = false;
   oauthCallbackPromise;
   server;
+  trigger;
   constructor(config) {
     this.transport = new HttpSessionTransport({
       url: config.serverUrl || MCP_SERVER_URL,
@@ -1579,6 +1655,10 @@ class MCPClientBase {
         this.authState.set(provider, { authenticated: false });
       }
     }
+    const integrationHeaderValue = this.getIntegrationHeaderValue();
+    if (integrationHeaderValue && this.transport.setHeader) {
+      this.transport.setHeader("X-Integrations", integrationHeaderValue);
+    }
     const providers = this.integrations.filter((p) => p.oauth).map((p) => p.oauth.provider);
     const usingDatabaseCallbacks = !!config.getProviderToken;
     if (usingDatabaseCallbacks) {
@@ -1654,6 +1734,13 @@ class MCPClientBase {
       this.todoist = this.createIntegrationProxy("todoist");
     }
     this.server = this.createServerProxy();
+    this.trigger = new TriggerClient({
+      apiRouteBase: this.apiRouteBase,
+      apiBaseUrl: this.apiBaseUrl,
+      getHeaders: () => ({
+        "X-Integrations": this.getIntegrationHeaderValue()
+      })
+    });
     this.initializeIntegrations();
   }
   getDefaultRedirectUri(oauthApiBase, apiBaseUrl) {
@@ -1683,9 +1770,24 @@ class MCPClientBase {
       }
     });
   }
+  getIntegrationHeaderValue() {
+    return this.integrations.map((integration) => integration.id).join(",");
+  }
   createServerProxy() {
     return new Proxy({}, {
       get: (_target, methodName) => {
+        if (methodName === "listConfiguredIntegrations") {
+          return async () => ({
+            integrations: this.integrations.map((integration) => ({
+              id: integration.id,
+              name: integration.name || integration.id,
+              tools: integration.tools,
+              hasOAuth: !!integration.oauth,
+              scopes: integration.oauth?.scopes,
+              provider: integration.oauth?.provider
+            }))
+          });
+        }
         return async (args, options) => {
           const toolName = methodToToolName(methodName, "");
           const finalToolName = toolName.startsWith("_") ? toolName.substring(1) : toolName;
@@ -1791,6 +1893,10 @@ class MCPClientBase {
     const headers = {
       "Content-Type": "application/json"
     };
+    const integrationsHeader = this.getIntegrationHeaderValue();
+    if (integrationsHeader) {
+      headers["X-Integrations"] = integrationsHeader;
+    }
     if (provider) {
       const tokenData = await this.oauthManager.getProviderToken(provider, undefined, options?.context);
       if (tokenData) {
@@ -7617,6 +7723,71 @@ var init_ai = __esm(() => {
   init_google();
 });
 
+// ../../node_modules/nanoid/url-alphabet/index.js
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+var init_url_alphabet = () => {};
+
+// ../../node_modules/nanoid/index.js
+import crypto2 from "crypto";
+var POOL_SIZE_MULTIPLIER = 128, pool, poolOffset, fillPool = (bytes) => {
+  if (!pool || pool.length < bytes) {
+    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
+    crypto2.randomFillSync(pool);
+    poolOffset = 0;
+  } else if (poolOffset + bytes > pool.length) {
+    crypto2.randomFillSync(pool);
+    poolOffset = 0;
+  }
+  poolOffset += bytes;
+}, nanoid = (size = 21) => {
+  fillPool(size |= 0);
+  let id = "";
+  for (let i = poolOffset - size;i < poolOffset; i++) {
+    id += urlAlphabet[pool[i] & 63];
+  }
+  return id;
+};
+var init_nanoid = __esm(() => {
+  init_url_alphabet();
+});
+
+// ../triggers/utils.ts
+var exports_utils = {};
+__export(exports_utils, {
+  validateStatusTransition: () => validateStatusTransition,
+  generateTriggerId: () => generateTriggerId,
+  extractProviderFromToolName: () => extractProviderFromToolName,
+  calculateHasMore: () => calculateHasMore
+});
+function generateTriggerId() {
+  return `trig_${nanoid(12)}`;
+}
+function extractProviderFromToolName(toolName) {
+  const parts = toolName.split("_");
+  return parts[0] || toolName;
+}
+function validateStatusTransition(currentStatus, targetStatus) {
+  if (targetStatus === "paused" && currentStatus !== "active") {
+    return {
+      valid: false,
+      error: `Cannot pause trigger with status '${currentStatus}'. Only 'active' triggers can be paused.`
+    };
+  }
+  if (targetStatus === "active" && currentStatus !== "paused") {
+    return {
+      valid: false,
+      error: `Cannot resume trigger with status '${currentStatus}'. Only 'paused' triggers can be resumed.`
+    };
+  }
+  return { valid: true };
+}
+function calculateHasMore(offset, returnedCount, total) {
+  return offset + returnedCount < total;
+}
+var init_utils2 = __esm(() => {
+  init_nanoid();
+});
+
 // ../server.ts
 var exports_server = {};
 __export(exports_server, {
@@ -7816,6 +7987,7 @@ function createMCPServer(config) {
       try {
         const body = await webRequest.json();
         const authHeader = webRequest.headers.get("authorization");
+        const integrationsHeader = webRequest.headers.get("x-integrations");
         const { OAuthHandler } = await Promise.resolve().then(() => exports_base_handler);
         const oauthHandler = new OAuthHandler({
           providers,
@@ -7825,7 +7997,7 @@ function createMCPServer(config) {
           removeProviderToken: config.removeProviderToken,
           getSessionContext: config.getSessionContext
         });
-        const result = await oauthHandler.handleToolCall(body, authHeader);
+        const result = await oauthHandler.handleToolCall(body, authHeader, integrationsHeader);
         const response2 = Response.json(result);
         if (oauthHandler.hasDatabaseCallbacks()) {
           response2.headers.set("X-Integrate-Use-Database", "true");
@@ -7836,13 +8008,308 @@ function createMCPServer(config) {
         return Response.json({ error: error.message || "Failed to execute tool call" }, { status: error.statusCode || 500 });
       }
     }
+    if (segments.length >= 1 && segments[0] === "triggers") {
+      if (!config.triggers) {
+        return Response.json({ error: "Triggers not configured. Add triggers callbacks to createMCPServer config." }, { status: 501 });
+      }
+      try {
+        const context2 = config.getSessionContext ? await config.getSessionContext(webRequest) : undefined;
+        if (segments.length === 1) {
+          if (method === "GET") {
+            const url = new URL(webRequest.url);
+            const params = {
+              status: url.searchParams.get("status"),
+              toolName: url.searchParams.get("toolName") || undefined,
+              limit: url.searchParams.get("limit") ? parseInt(url.searchParams.get("limit")) : undefined,
+              offset: url.searchParams.get("offset") ? parseInt(url.searchParams.get("offset")) : undefined
+            };
+            const callbackResult = await config.triggers.list(params, context2);
+            const { calculateHasMore: calculateHasMore2 } = await Promise.resolve().then(() => (init_utils2(), exports_utils));
+            const offset = params.offset || 0;
+            const hasMore = calculateHasMore2(offset, callbackResult.triggers.length, callbackResult.total);
+            return Response.json({
+              triggers: callbackResult.triggers,
+              total: callbackResult.total,
+              hasMore
+            });
+          } else if (method === "POST") {
+            const body = await webRequest.json();
+            const { generateTriggerId: generateTriggerId2, extractProviderFromToolName: extractProviderFromToolName2 } = await Promise.resolve().then(() => (init_utils2(), exports_utils));
+            const triggerId = generateTriggerId2();
+            const provider = body.toolName ? extractProviderFromToolName2(body.toolName) : undefined;
+            const trigger = {
+              id: triggerId,
+              ...body,
+              provider,
+              status: body.status || "active",
+              createdAt: new Date().toISOString(),
+              updatedAt: new Date().toISOString(),
+              runCount: 0
+            };
+            const created = await config.triggers.create(trigger, context2);
+            const schedulerUrl = config.schedulerUrl || config.serverUrl || "https://mcp.integrate.dev";
+            const callbackBaseUrl = process.env.INTEGRATE_URL || (typeof window !== "undefined" ? window.location.origin : "http://localhost:3000");
+            try {
+              await fetch(`${schedulerUrl}/scheduler/register`, {
+                method: "POST",
+                headers: {
+                  "Content-Type": "application/json",
+                  "X-API-KEY": config.apiKey || ""
+                },
+                body: JSON.stringify({
+                  triggerId: created.id,
+                  schedule: created.schedule,
+                  callbackUrl: `${callbackBaseUrl}/api/integrate/triggers/${created.id}/execute`,
+                  completeUrl: `${callbackBaseUrl}/api/integrate/triggers/${created.id}/complete`,
+                  metadata: {
+                    userId: context2?.userId,
+                    provider: created.provider
+                  }
+                })
+              });
+            } catch (scheduleError) {
+              console.error("[Trigger] Failed to register with scheduler:", scheduleError);
+            }
+            return Response.json(created, { status: 201 });
+          }
+        } else if (segments.length >= 2) {
+          const triggerId = segments[1];
+          if (!triggerId) {
+            return Response.json({ error: "Trigger ID is required" }, { status: 400 });
+          }
+          const subAction = segments.length > 2 ? segments[2] : undefined;
+          if (subAction === "pause" && method === "POST") {
+            const trigger = await config.triggers.get(triggerId, context2);
+            if (!trigger) {
+              return Response.json({ error: "Trigger not found" }, { status: 404 });
+            }
+            const { validateStatusTransition: validateStatusTransition2 } = await Promise.resolve().then(() => (init_utils2(), exports_utils));
+            const validation = validateStatusTransition2(trigger.status, "paused");
+            if (!validation.valid) {
+              return Response.json({ error: validation.error }, { status: 400 });
+            }
+            const updated = await config.triggers.update(triggerId, {
+              status: "paused",
+              updatedAt: new Date().toISOString()
+            }, context2);
+            const schedulerUrl = config.schedulerUrl || config.serverUrl || "https://mcp.integrate.dev";
+            try {
+              await fetch(`${schedulerUrl}/scheduler/pause`, {
+                method: "POST",
+                headers: {
+                  "Content-Type": "application/json",
+                  "X-API-KEY": config.apiKey || ""
+                },
+                body: JSON.stringify({ triggerId })
+              });
+            } catch (error) {
+              console.error("[Trigger] Failed to pause in scheduler:", error);
+            }
+            return Response.json(updated);
+          } else if (subAction === "resume" && method === "POST") {
+            const trigger = await config.triggers.get(triggerId, context2);
+            if (!trigger) {
+              return Response.json({ error: "Trigger not found" }, { status: 404 });
+            }
+            const { validateStatusTransition: validateStatusTransition2 } = await Promise.resolve().then(() => (init_utils2(), exports_utils));
+            const validation = validateStatusTransition2(trigger.status, "active");
+            if (!validation.valid) {
+              return Response.json({ error: validation.error }, { status: 400 });
+            }
+            const updated = await config.triggers.update(triggerId, {
+              status: "active",
+              updatedAt: new Date().toISOString()
+            }, context2);
+            const schedulerUrl = config.schedulerUrl || config.serverUrl || "https://mcp.integrate.dev";
+            try {
+              await fetch(`${schedulerUrl}/scheduler/resume`, {
+                method: "POST",
+                headers: {
+                  "Content-Type": "application/json",
+                  "X-API-KEY": config.apiKey || ""
+                },
+                body: JSON.stringify({ triggerId })
+              });
+            } catch (error) {
+              console.error("[Trigger] Failed to resume in scheduler:", error);
+            }
+            return Response.json(updated);
+          } else if (subAction === "run" && method === "POST") {
+            const trigger = await config.triggers.get(triggerId, context2);
+            if (!trigger) {
+              return Response.json({ error: "Trigger not found" }, { status: 404 });
+            }
+            if (!trigger.provider) {
+              return Response.json({ error: "Trigger has no provider configured" }, { status: 400 });
+            }
+            const providerToken = config.getProviderToken ? await config.getProviderToken(trigger.provider, undefined, context2) : undefined;
+            if (!providerToken) {
+              return Response.json({ error: "No OAuth token available for this trigger" }, { status: 401 });
+            }
+            const { OAuthHandler } = await Promise.resolve().then(() => exports_base_handler);
+            const oauthHandler = new OAuthHandler({
+              providers,
+              serverUrl: config.serverUrl,
+              apiKey: config.apiKey,
+              setProviderToken: config.setProviderToken,
+              removeProviderToken: config.removeProviderToken,
+              getSessionContext: config.getSessionContext
+            });
+            const startTime = Date.now();
+            try {
+              const result = await oauthHandler.handleToolCall({ name: trigger.toolName, arguments: trigger.toolArguments }, `Bearer ${providerToken.accessToken}`, null);
+              const duration = Date.now() - startTime;
+              const executionResult = {
+                success: true,
+                result,
+                executedAt: new Date().toISOString(),
+                duration
+              };
+              await config.triggers.update(triggerId, {
+                lastRunAt: executionResult.executedAt,
+                runCount: (trigger.runCount || 0) + 1,
+                lastResult: result,
+                lastError: undefined
+              }, context2);
+              return Response.json(executionResult);
+            } catch (error) {
+              const duration = Date.now() - startTime;
+              const executionResult = {
+                success: false,
+                error: error.message || "Tool execution failed",
+                executedAt: new Date().toISOString(),
+                duration
+              };
+              await config.triggers.update(triggerId, {
+                lastRunAt: executionResult.executedAt,
+                runCount: (trigger.runCount || 0) + 1,
+                lastError: error.message,
+                status: "failed"
+              }, context2);
+              return Response.json(executionResult, { status: 500 });
+            }
+          } else if (subAction === "execute" && method === "GET") {
+            const apiKey = webRequest.headers.get("x-api-key");
+            if (!apiKey || apiKey !== config.apiKey) {
+              return Response.json({ error: "Unauthorized" }, { status: 401 });
+            }
+            const trigger = await config.triggers.get(triggerId, context2);
+            if (!trigger) {
+              return Response.json({ error: "Trigger not found" }, { status: 404 });
+            }
+            if (!trigger.provider) {
+              return Response.json({ error: "Trigger has no provider configured" }, { status: 400 });
+            }
+            const providerToken = config.getProviderToken ? await config.getProviderToken(trigger.provider, undefined, context2) : undefined;
+            if (!providerToken) {
+              return Response.json({ error: "No OAuth token available for this trigger" }, { status: 401 });
+            }
+            return Response.json({
+              trigger: {
+                id: trigger.id,
+                toolName: trigger.toolName,
+                toolArguments: trigger.toolArguments,
+                provider: trigger.provider
+              },
+              accessToken: providerToken.accessToken,
+              tokenType: providerToken.tokenType || "Bearer"
+            });
+          } else if (subAction === "complete" && method === "POST") {
+            const apiKey = webRequest.headers.get("x-api-key");
+            if (!apiKey || apiKey !== config.apiKey) {
+              return Response.json({ error: "Unauthorized" }, { status: 401 });
+            }
+            const body = await webRequest.json();
+            const trigger = await config.triggers.get(triggerId, context2);
+            if (!trigger) {
+              return Response.json({ error: "Trigger not found" }, { status: 404 });
+            }
+            const updates = {
+              lastRunAt: body.executedAt,
+              runCount: (trigger.runCount || 0) + 1
+            };
+            if (body.success) {
+              updates.lastResult = body.result;
+              updates.lastError = undefined;
+              if (trigger.schedule.type === "once") {
+                updates.status = "completed";
+              }
+            } else {
+              updates.lastError = body.error;
+              updates.status = "failed";
+            }
+            await config.triggers.update(triggerId, updates, context2);
+            return Response.json({ success: true });
+          } else if (!subAction && method === "GET") {
+            const trigger = await config.triggers.get(triggerId, context2);
+            if (!trigger) {
+              return Response.json({ error: "Trigger not found" }, { status: 404 });
+            }
+            return Response.json(trigger);
+          } else if (!subAction && method === "PATCH") {
+            const body = await webRequest.json();
+            const trigger = await config.triggers.get(triggerId, context2);
+            if (!trigger) {
+              return Response.json({ error: "Trigger not found" }, { status: 404 });
+            }
+            const updates = {
+              ...body,
+              updatedAt: new Date().toISOString()
+            };
+            const updated = await config.triggers.update(triggerId, updates, context2);
+            if (body.schedule) {
+              const schedulerUrl = config.schedulerUrl || config.serverUrl || "https://mcp.integrate.dev";
+              try {
+                await fetch(`${schedulerUrl}/scheduler/update`, {
+                  method: "POST",
+                  headers: {
+                    "Content-Type": "application/json",
+                    "X-API-KEY": config.apiKey || ""
+                  },
+                  body: JSON.stringify({
+                    triggerId,
+                    schedule: body.schedule
+                  })
+                });
+              } catch (error) {
+                console.error("[Trigger] Failed to update scheduler:", error);
+              }
+            }
+            return Response.json(updated);
+          } else if (!subAction && method === "DELETE") {
+            await config.triggers.delete(triggerId, context2);
+            const schedulerUrl = config.schedulerUrl || config.serverUrl || "https://mcp.integrate.dev";
+            try {
+              await fetch(`${schedulerUrl}/scheduler/unregister`, {
+                method: "POST",
+                headers: {
+                  "Content-Type": "application/json",
+                  "X-API-KEY": config.apiKey || ""
+                },
+                body: JSON.stringify({ triggerId })
+              });
+            } catch (error) {
+              console.error("[Trigger] Failed to unregister from scheduler:", error);
+            }
+            return new Response(null, { status: 204 });
+          }
+        }
+        return Response.json({ error: "Invalid trigger route or method" }, { status: 404 });
+      } catch (error) {
+        console.error("[Trigger] Error:", error);
+        return Response.json({ error: error.message || "Failed to process trigger request" }, { status: error.statusCode || 500 });
+      }
+    }
     if (segments.length > 0) {
-      if (segments.length === 2 && segments[0] !== "oauth") {
+      if (segments.length === 2 && segments[0] !== "oauth" && segments[0] !== "triggers") {
         return Response.json({ error: `Invalid route: /${segments.join("/")}` }, { status: 404 });
       }
       if (segments.length === 1 && segments[0] === "mcp") {
         return Response.json({ error: `Method ${method} not allowed for /mcp route. Use POST.` }, { status: 405 });
       }
+      if (segments.length >= 1 && segments[0] === "triggers") {
+        return Response.json({ error: `Invalid trigger route or method` }, { status: 404 });
+      }
     }
     if (method === "GET" && action === "callback") {
       const url = new URL(webRequest.url);
@@ -8724,7 +9191,7 @@ class OAuthHandler {
     const data = await response.json();
     return data;
   }
-  async handleToolCall(request, authHeader) {
+  async handleToolCall(request, authHeader, integrationsHeader) {
     const url = this.serverUrl;
     const headers = this.getHeaders({
       "Content-Type": "application/json"
@@ -8732,6 +9199,9 @@ class OAuthHandler {
     if (authHeader && authHeader.startsWith("Bearer ")) {
       headers["Authorization"] = authHeader;
     }
+    if (integrationsHeader) {
+      headers["X-Integrations"] = integrationsHeader;
+    }
     const jsonRpcRequest = {
       jsonrpc: "2.0",
       id: Date.now() + Math.random(),
@@ -8876,7 +9346,8 @@ function createNextOAuthHandler(config) {
       try {
         const body = await req.json();
         const authHeader = req.headers.get("authorization");
-        const result = await handler.handleToolCall(body, authHeader);
+        const integrationsHeader = req.headers.get("x-integrations");
+        const result = await handler.handleToolCall(body, authHeader, integrationsHeader);
         return Response.json(result);
       } catch (error) {
         console.error("[MCP Tool Call] Error:", error);