@zapier/zapier-sdk 0.0.1 → 0.0.2

package/dist/actions-sdk.js

@@ -0,0 +1,1194 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createActionsSdk = createActionsSdk;
+const types_1 = require("./types");
+const schemas_1 = require("./schemas");
+__exportStar(require("./schemas"), exports);
+__exportStar(require("./output-schemas"), exports);
+function createActionsSdk(options = {}) {
+    // Auto-load .env files (searches up directory tree)
+    try {
+        const { findUpSync } = require("find-up");
+        const envPath = findUpSync(".env");
+        if (envPath) {
+            require("dotenv").config({ path: envPath, quiet: true });
+        }
+    }
+    catch {
+        // Silently fail if dotenv/find-up not available or .env not found
+    }
+    const { fetch: customFetch = globalThis.fetch, baseUrl = "https://zapier.com", token, authentications = {}, debug = false, } = options;
+    // If no token provided, try to get it from environment variable
+    const finalToken = token || process.env.ZAPIER_TOKEN;
+    const debugLog = createDebugLogger(debug);
+    // Wrap fetch with debug logging if debug is enabled
+    const wrappedFetch = debug
+        ? createDebugFetch({
+            originalFetch: customFetch,
+            debugLog,
+        })
+        : customFetch;
+    // Create SDK object - we'll populate services after creation to avoid circular dependency
+    const sdk = {};
+    const appsService = createAppsService({
+        fetch: wrappedFetch,
+        baseUrl,
+        token: finalToken,
+        authentications,
+        debugLog: debug ? debugLog : undefined,
+        sdk,
+    });
+    const actionsService = createActionsService({
+        fetch: wrappedFetch,
+        baseUrl,
+        token: finalToken,
+        authentications,
+        debugLog,
+        sdk,
+    });
+    const authsService = createAuthsService({
+        fetch: wrappedFetch,
+        baseUrl,
+        token: finalToken,
+        authentications,
+        debugLog,
+        sdk,
+    });
+    const fieldsService = createFieldsService({
+        fetch: wrappedFetch,
+        baseUrl,
+        token: finalToken,
+        authentications,
+        debugLog,
+        sdk,
+    });
+    // Create root namespace tools
+    const generateFunction = async (options) => {
+        // Validate options using schema
+        const validatedOptions = schemas_1.SdkSchemas.generate.parse(options);
+        return await generateTypes(validatedOptions, sdk);
+    };
+    const bundleFunction = async (options) => {
+        // Validate options using schema
+        const validatedOptions = schemas_1.SdkSchemas.bundle.parse(options);
+        return await bundleCode(validatedOptions);
+    };
+    // Populate the SDK object
+    sdk.apps = appsService;
+    sdk.actions = actionsService;
+    sdk.auths = authsService;
+    sdk.fields = fieldsService;
+    sdk.generate = generateFunction;
+    sdk.bundle = bundleFunction;
+    if (debug) {
+        debugLog("🚀 Zapier SDK initialized", {
+            baseUrl,
+            hasAuth: !!finalToken,
+            tokenType: finalToken ? (isJwt(finalToken) ? "JWT" : "Bearer") : "none",
+            appAuthCount: authentications ? Object.keys(authentications).length : 0,
+        });
+    }
+    return sdk;
+}
+function createAppsService(options) {
+    const { fetch, baseUrl, debugLog } = options;
+    return {
+        async list(options) {
+            const url = new URL("/api/v4/apps/", baseUrl);
+            // Add query parameters if provided
+            if (options?.category) {
+                url.searchParams.set("category", options.category);
+            }
+            if (options?.limit) {
+                url.searchParams.set("limit", options.limit.toString());
+            }
+            if (options?.offset) {
+                url.searchParams.set("offset", options.offset.toString());
+            }
+            const response = await fetch(url.toString());
+            if (!response.ok) {
+                throw new Error(`Failed to fetch apps: ${response.status} ${response.statusText}`);
+            }
+            const data = await response.json();
+            // Debug: Log pagination info if debug is enabled
+            if (debugLog) {
+                debugLog("API Response Pagination Info", {
+                    resultsCount: data.results?.length || 0,
+                    hasNext: !!data.next,
+                    hasPrevious: !!data.previous,
+                    count: data.count,
+                    nextUrl: data.next,
+                    previousUrl: data.previous,
+                });
+            }
+            // Transform API response to our Integration interface
+            const apps = data.results?.map((app) => ({
+                key: app.slug,
+                name: app.name,
+                description: app.description,
+                version: "1.0.0", // API doesn't provide version
+                category: app.category?.name,
+                actions: [], // Will be populated separately
+                triggers: [],
+                current_implementation_id: app.current_implementation_id,
+            })) || [];
+            // Add pagination metadata to the response
+            if (apps.length > 0) {
+                apps.__pagination = {
+                    count: data.count,
+                    hasNext: !!data.next,
+                    hasPrevious: !!data.previous,
+                    nextUrl: data.next,
+                    previousUrl: data.previous,
+                };
+            }
+            return apps;
+        },
+        async get(options) {
+            const { key } = options;
+            const url = new URL(`/api/v4/apps/${key}/`, baseUrl);
+            const response = await fetch(url.toString());
+            if (!response.ok) {
+                if (response.status === 404) {
+                    throw new types_1.AppNotFoundError(key);
+                }
+                throw new Error(`Failed to fetch app: ${response.status} ${response.statusText}`);
+            }
+            const app = await response.json();
+            return {
+                key: app.slug,
+                name: app.name,
+                description: app.description,
+                version: "1.0.0",
+                category: app.category?.name,
+                actions: [],
+                triggers: [],
+                current_implementation_id: app.current_implementation_id,
+            };
+        },
+    };
+}
+function createAuthsService(options) {
+    const { fetch, baseUrl, token, authentications, debugLog, sdk } = options;
+    // Local function to handle the actual API fetching
+    const listAuths = async (options) => {
+        const url = new URL("/api/v4/authentications/", baseUrl);
+        // Handle appKey filtering by getting the selected_api first
+        if (options?.appKey) {
+            try {
+                // Use the SDK's getApp function instead of duplicating the API call
+                const appData = await sdk.apps.get({ key: options.appKey });
+                const selectedApi = appData.current_implementation_id;
+                if (selectedApi) {
+                    // Use versionless_selected_api to find auths across all app versions
+                    // Extract the base name without the version (e.g., "SlackCLIAPI" from "SlackCLIAPI@1.21.1")
+                    const versionlessApi = selectedApi.split("@")[0];
+                    url.searchParams.set("versionless_selected_api", versionlessApi);
+                }
+            }
+            catch (error) {
+                // If it's an AppNotFoundError, re-throw it
+                if (error instanceof types_1.AppNotFoundError) {
+                    throw error;
+                }
+                // For other errors, continue without app filtering
+                console.warn(`Warning: Could not filter by app ${options.appKey}:`, error instanceof Error ? error.message : "Unknown error");
+            }
+        }
+        // Add other query parameters if provided
+        if (options?.account_id) {
+            url.searchParams.set("account_id", options.account_id);
+        }
+        if (options?.owner) {
+            url.searchParams.set("owner", options.owner);
+        }
+        if (options?.limit) {
+            url.searchParams.set("limit", options.limit.toString());
+        }
+        if (options?.offset) {
+            url.searchParams.set("offset", options.offset.toString());
+        }
+        // Build headers with auth if available
+        const headers = {};
+        if (token) {
+            headers["Authorization"] = getAuthorizationHeader(token);
+        }
+        else {
+            throw new Error("Authentication token is required to list authentications. Please provide token when creating the SDK.");
+        }
+        const response = await fetch(url.toString(), { headers });
+        if (!response.ok) {
+            if (response.status === 401) {
+                throw new Error(`Authentication failed. Your token may not have permission to access authentications or may be expired. (HTTP ${response.status})`);
+            }
+            if (response.status === 403) {
+                throw new Error(`Access forbidden. Your token may not have the required scopes to list authentications. (HTTP ${response.status})`);
+            }
+            throw new Error(`Failed to fetch authentications: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        // Debug: Log pagination info if debug is enabled
+        if (debugLog) {
+            debugLog("API Response Pagination Info", {
+                resultsCount: data.results?.length || 0,
+                hasNext: !!data.next,
+                hasPrevious: !!data.previous,
+                count: data.count,
+                nextUrl: data.next,
+                previousUrl: data.previous,
+            });
+        }
+        // Transform API response
+        const auths = data.results || [];
+        // Add pagination metadata to the response
+        if (auths.length > 0) {
+            auths.__pagination = {
+                count: data.count,
+                hasNext: !!data.next,
+                hasPrevious: !!data.previous,
+                nextUrl: data.next,
+                previousUrl: data.previous,
+            };
+        }
+        return auths;
+    };
+    return {
+        async list(options) {
+            // If a limit is provided and no specific owner filter, prioritize owned auths
+            if (options?.limit && options?.owner === undefined) {
+                // First get owned auths
+                const ownedAuths = await listAuths({
+                    ...options,
+                    owner: "me",
+                });
+                // If we have enough owned auths, just slice and return
+                if (ownedAuths.length >= options.limit) {
+                    return ownedAuths.slice(0, options.limit);
+                }
+                // Get all auths up to the original limit to fill remaining slots
+                const allAuths = await listAuths({
+                    ...options,
+                    owner: undefined,
+                });
+                // Filter out auths the user already owns to avoid duplicates
+                const ownedAuthIds = new Set(ownedAuths.map((auth) => auth.id));
+                const additionalAuths = allAuths.filter((auth) => !ownedAuthIds.has(auth.id));
+                // Combine and slice to the requested limit
+                const combined = [...ownedAuths, ...additionalAuths];
+                return combined.slice(0, options.limit);
+            }
+            // Standard implementation for non-prioritized requests
+            return listAuths(options);
+        },
+        find(options) {
+            if (!authentications) {
+                throw new Error(`No authentication configured`);
+            }
+            const auths = authentications[options.appKey] || [];
+            if (auths.length === 0) {
+                throw new Error(`No authentication configured for app "${options.appKey}"`);
+            }
+            if (auths.length > 1) {
+                throw new Error(`Multiple authentications found for app "${options.appKey}". Please specify which one to use.`);
+            }
+            return auths[0].id;
+        },
+    };
+}
+function createFieldsService(options) {
+    const { fetch, baseUrl, token, sdk } = options;
+    return {
+        async list(options) {
+            // Map consistent parameter names to internal API names
+            const { app, action, type, authId, params } = options;
+            const appKey = app;
+            const actionKey = action;
+            const actionType = type;
+            // Build headers with auth if available
+            const headers = {};
+            if (token) {
+                headers["Authorization"] = getAuthorizationHeader(token);
+            }
+            // Use the SDK's getApp function instead of duplicating the API call
+            const appData = await sdk.apps.get({ key: appKey });
+            const selectedApi = appData.current_implementation_id;
+            if (!selectedApi) {
+                throw new Error("No current_implementation_id found for app");
+            }
+            // Build needs request
+            const needsRequest = {
+                selected_api: selectedApi,
+                action: actionKey,
+                type_of: actionType,
+                authentication_id: authId,
+                params: params || {},
+            };
+            const needsUrl = new URL("/api/v4/implementations/needs/", baseUrl);
+            // Add Content-Type to headers
+            const needsHeaders = { ...headers, "Content-Type": "application/json" };
+            const needsResponse = await fetch(needsUrl.toString(), {
+                method: "POST",
+                headers: needsHeaders,
+                body: JSON.stringify(needsRequest),
+            });
+            if (!needsResponse.ok) {
+                // Add more detailed error info for debugging
+                let errorMessage = `Failed to fetch action fields: ${needsResponse.status} ${needsResponse.statusText}`;
+                try {
+                    const errorBody = await needsResponse.text();
+                    errorMessage += ` - ${errorBody}`;
+                }
+                catch {
+                    // Ignore error reading response body
+                }
+                throw new Error(errorMessage);
+            }
+            const needsData = await needsResponse.json();
+            if (!needsData.success) {
+                throw new Error(`Failed to get action fields: ${needsData.errors?.join(", ") || "Unknown error"}`);
+            }
+            // Transform API response to our ActionField interface
+            return (needsData.needs || []).map((need) => ({
+                key: need.key,
+                label: need.label,
+                required: need.required || false,
+                type: need.type,
+                helpText: need.help_text,
+                helpTextHtml: need.help_text_html,
+                choices: need.choices?.map((choice) => ({
+                    value: choice.value,
+                    label: choice.label,
+                })),
+                default: need.default,
+                placeholder: need.placeholder,
+                computed: need.computed,
+                customField: need.custom_field,
+                dependsOn: need.depends_on,
+                format: need.format,
+                inputFormat: need.input_format,
+            }));
+        },
+    };
+}
+function createActionsService(options) {
+    const { fetch, baseUrl, token, authentications, debugLog, sdk } = options;
+    // Create the base service with named methods
+    const baseService = {
+        async list(options) {
+            // If filtering by appKey, use optimized approach with selected_apis parameter
+            if (options?.appKey) {
+                try {
+                    // Use the SDK's getApp function instead of duplicating the API call
+                    const appData = await sdk.apps.get({ key: options.appKey });
+                    // Extract implementation name from current_implementation_id (e.g., "SlackCLIAPI@1.20.0" -> "SlackCLIAPI")
+                    const implementationId = appData.current_implementation_id?.split("@")[0];
+                    if (!implementationId) {
+                        throw new Error("No current_implementation_id found for app");
+                    }
+                    const url = new URL("/api/v4/implementations/", baseUrl);
+                    url.searchParams.set("global", "true");
+                    url.searchParams.set("public_only", "true");
+                    url.searchParams.set("selected_apis", implementationId);
+                    const response = await fetch(url.toString());
+                    if (!response.ok) {
+                        throw new Error(`Failed to fetch actions: ${response.status} ${response.statusText}`);
+                    }
+                    const data = await response.json();
+                    const actions = [];
+                    // Transform implementations to actions
+                    for (const implementation of data.results || []) {
+                        if (implementation.actions) {
+                            for (const action of implementation.actions) {
+                                const transformedAction = {
+                                    key: action.key,
+                                    name: action.name || action.label,
+                                    description: action.description || "",
+                                    appKey: implementation.slug || "",
+                                    type: action.type || action.type_of || "read",
+                                    inputFields: [], // Would need additional API call for detailed fields
+                                    outputFields: [],
+                                };
+                                // Apply type filter if provided
+                                if (options?.type && transformedAction.type !== options.type) {
+                                    continue;
+                                }
+                                actions.push(transformedAction);
+                            }
+                        }
+                    }
+                    // Add pagination metadata for app-specific queries
+                    if (actions.length > 0) {
+                        actions.__pagination = {
+                            count: data.count,
+                            hasNext: !!data.next,
+                            hasPrevious: !!data.previous,
+                            nextUrl: data.next,
+                            previousUrl: data.previous,
+                        };
+                    }
+                    return actions;
+                }
+                catch (error) {
+                    // If it's an AppNotFoundError, don't try fallback - just re-throw
+                    if (error instanceof types_1.AppNotFoundError) {
+                        throw error;
+                    }
+                    // Fallback to original approach if optimized approach fails
+                    console.warn("Optimized app lookup failed, falling back to full scan:", error);
+                }
+            }
+            // Original approach for general queries or when optimization fails
+            const url = new URL("/api/v4/implementations/", baseUrl);
+            // Add query parameters
+            url.searchParams.set("global", "true");
+            url.searchParams.set("public_only", "true");
+            const response = await fetch(url.toString());
+            if (!response.ok) {
+                throw new Error(`Failed to fetch actions: ${response.status} ${response.statusText}`);
+            }
+            const data = await response.json();
+            const actions = [];
+            // Transform implementations to actions
+            for (const implementation of data.results || []) {
+                if (implementation.actions) {
+                    for (const action of implementation.actions) {
+                        const transformedAction = {
+                            key: action.key,
+                            name: action.name || action.label,
+                            description: action.description || "",
+                            appKey: implementation.slug || "",
+                            type: action.type || action.type_of || "read",
+                            inputFields: [], // Would need additional API call for detailed fields
+                            outputFields: [],
+                        };
+                        // Apply filters
+                        if (options?.appKey &&
+                            transformedAction.appKey !== options.appKey) {
+                            continue;
+                        }
+                        if (options?.type && transformedAction.type !== options.type) {
+                            continue;
+                        }
+                        actions.push(transformedAction);
+                    }
+                }
+            }
+            // Add pagination metadata for general queries
+            if (actions.length > 0) {
+                actions.__pagination = {
+                    count: data.count,
+                    hasNext: !!data.next,
+                    hasPrevious: !!data.previous,
+                    nextUrl: data.next,
+                    previousUrl: data.previous,
+                };
+            }
+            return actions;
+        },
+        async get(options) {
+            const { app, action: actionKey, type } = options;
+            const actions = await baseService.list({ appKey: app });
+            const action = actions.find((a) => a.key === actionKey && a.type === type);
+            if (!action) {
+                throw new Error(`Action not found: ${actionKey} with type ${type}`);
+            }
+            return action;
+        },
+        async fields(options) {
+            return await sdk.fields.list(options);
+        },
+        async getFields(options) {
+            return await sdk.fields.list(options);
+        },
+        // run will be replaced with function/proxy pattern below
+    };
+    // Create the run function with proxy capabilities
+    const runFunction = async (params) => {
+        const { app, type, action, inputs, authId: providedAuthId } = params;
+        // Validate that the action exists
+        const actionData = await baseService.get({
+            app: app,
+            action: action,
+            type: type,
+        });
+        // Validate action type matches
+        if (actionData.type !== type) {
+            throw new Error(`Action type mismatch: expected ${type}, got ${actionData.type}`);
+        }
+        // Resolve auth ID for this specific app
+        let authId = providedAuthId;
+        if (!authId && authentications) {
+            const auths = authentications[app] || [];
+            if (auths.length === 0) {
+                throw new Error(`No authentication configured for app "${app}"`);
+            }
+            if (auths.length > 1) {
+                throw new Error(`Multiple authentications found for app "${app}". Please specify which one to use.`);
+            }
+            authId = auths[0].id;
+        }
+        // Execute the action using the appropriate API based on action type
+        const startTime = Date.now();
+        const result = await executeActionWithStrategy({
+            fetch,
+            baseUrl,
+            appSlug: app,
+            actionKey: action,
+            actionType: actionData.type,
+            executionOptions: { inputs: inputs || {} },
+            auth: token ? { token: token, authentication_id: authId } : undefined,
+            debugLog,
+            sdk,
+        });
+        const executionTime = Date.now() - startTime;
+        return {
+            success: true,
+            data: result,
+            metadata: {
+                executionTime,
+                requestId: generateRequestId(),
+            },
+        };
+    };
+    // Create proxy wrapper for the run function
+    const runWithProxy = new Proxy(runFunction, {
+        get(target, prop) {
+            if (typeof prop === "string") {
+                // Return app-level proxy
+                return new Proxy({}, {
+                    get(_target, actionType) {
+                        if (typeof actionType !== "string")
+                            return undefined;
+                        return new Proxy({}, {
+                            get(_target, actionKey) {
+                                if (typeof actionKey !== "string")
+                                    return undefined;
+                                // Return function that calls the main run function
+                                return async (options = {}) => {
+                                    return await runFunction({
+                                        app: prop,
+                                        type: actionType, // Cast because proxy string can't be typed as enum
+                                        action: actionKey,
+                                        inputs: options.inputs,
+                                        authId: options.authId,
+                                    });
+                                };
+                            },
+                        });
+                    },
+                });
+            }
+            return target[prop];
+        },
+    });
+    // Add the run function/proxy to the base service
+    baseService.run = runWithProxy;
+    // Return the service with the new run function/proxy
+    return baseService;
+}
+async function executeActionWithStrategy(options) {
+    const { fetch, baseUrl, appSlug, actionKey, actionType, executionOptions, auth, debugLog, sdk, } = options;
+    debugLog?.("🎯 Choosing execution strategy", { actionType });
+    // Actions API supports: read, read_bulk, write
+    // Invoke API supports: search, read, write, read_bulk, and more
+    const actionsApiTypes = ["read", "read_bulk", "write"];
+    const useActionsApi = actionsApiTypes.includes(actionType);
+    if (useActionsApi) {
+        debugLog?.("🔧 Using Actions API", {
+            actionType,
+            reason: "supported type",
+        });
+        return executeActionViaActionsApi({
+            fetch,
+            baseUrl,
+            appSlug,
+            actionKey,
+            actionType,
+            executionOptions,
+            auth,
+            debugLog,
+            sdk,
+        });
+    }
+    else {
+        debugLog?.("🔧 Using Invoke API", {
+            actionType,
+            reason: "unsupported by Actions API",
+        });
+        return executeActionViaInvokeApi({
+            fetch,
+            baseUrl,
+            appSlug,
+            actionKey,
+            actionType,
+            executionOptions,
+            auth,
+            debugLog,
+            sdk,
+        });
+    }
+}
+async function executeActionViaActionsApi(options) {
+    const { fetch, baseUrl, appSlug, actionKey, actionType, executionOptions, auth, sdk, } = options;
+    // Note: Action validation is handled by the caller before reaching this function
+    // Use the SDK's getApp function instead of duplicating the API call
+    const appData = await sdk.apps.get({ key: appSlug });
+    const selectedApi = appData.current_implementation_id;
+    if (!selectedApi) {
+        throw new Error("No current_implementation_id found for app");
+    }
+    if (!auth?.token) {
+        throw new Error("Authentication token is required. Please provide token when creating the SDK.");
+    }
+    // Determine if token is JWT and use appropriate prefix
+    const authHeader = getAuthorizationHeader(auth.token);
+    // Step 1: POST to /actions/v1/runs to start execution
+    const runRequest = {
+        data: {
+            authentication_id: auth.authentication_id || 1,
+            selected_api: selectedApi,
+            action_key: actionKey,
+            action_type: actionType,
+            inputs: executionOptions.inputs || {},
+        },
+    };
+    const runUrl = `${baseUrl}/api/actions/v1/runs`;
+    const headers = {
+        "Content-Type": "application/json",
+        Authorization: authHeader,
+    };
+    const runResponse = await fetch(runUrl, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(runRequest),
+    });
+    if (!runResponse.ok) {
+        throw new Error(`Failed to start action execution: POST ${runUrl} - ${runResponse.status} ${runResponse.statusText}`);
+    }
+    const runData = await runResponse.json();
+    const runId = runData.data.id;
+    // Step 2: Poll GET /actions/v1/runs/{run_id} for results
+    return await pollForResults({ fetch, baseUrl, runId, authHeader });
+}
+async function pollForResults(options) {
+    const { fetch, baseUrl, runId, authHeader } = options;
+    let delay = 50; // Start with 50ms
+    const maxDelay = 1000; // Cap at 1 second
+    const maxAttempts = 30; // Maximum number of polling attempts
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        const pollUrl = `${baseUrl}/api/actions/v1/runs/${runId}`;
+        const response = await fetch(pollUrl, {
+            headers: {
+                Authorization: authHeader,
+            },
+        });
+        if (response.status === 200) {
+            // Action completed
+            const result = await response.json();
+            return result.data;
+        }
+        else if (response.status === 202) {
+            // Still processing, wait and try again
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            delay = Math.min(delay * 2, maxDelay); // Double delay up to max
+            continue;
+        }
+        else {
+            // Error occurred
+            throw new Error(`Failed to fetch action results: GET ${pollUrl} - ${response.status} ${response.statusText}`);
+        }
+    }
+    throw new Error(`Action execution timed out after ${maxAttempts} attempts`);
+}
+async function executeActionViaInvokeApi(options) {
+    const { fetch, baseUrl, appSlug, actionKey, actionType, executionOptions, auth, sdk, } = options;
+    // Note: Action and app validation is handled by the caller before reaching this function
+    // Use the SDK's getApp function instead of duplicating the API call
+    const appData = await sdk.apps.get({ key: appSlug });
+    const selectedApi = appData.current_implementation_id;
+    if (!selectedApi) {
+        throw new Error("No current_implementation_id found for app");
+    }
+    if (!auth?.token) {
+        throw new Error("Authentication token is required. Please provide token when creating the SDK.");
+    }
+    // Determine if token is JWT and use appropriate prefix
+    const authHeader = getAuthorizationHeader(auth.token);
+    // Step 1: POST to /invoke/v1/invoke to start execution
+    const invokeRequest = {
+        selected_api: selectedApi,
+        action: actionKey,
+        type_of: actionType,
+        authentication_id: auth.authentication_id || 1,
+        params: executionOptions.inputs || {},
+    };
+    const invokeUrl = `${baseUrl}/api/invoke/v1/invoke`;
+    const headers = {
+        "Content-Type": "application/json",
+        Authorization: authHeader,
+    };
+    const invokeResponse = await fetch(invokeUrl, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(invokeRequest),
+    });
+    if (!invokeResponse.ok) {
+        throw new Error(`Failed to start action execution: POST ${invokeUrl} - ${invokeResponse.status} ${invokeResponse.statusText}`);
+    }
+    const invokeData = await invokeResponse.json();
+    const invocationId = invokeData.invocation_id;
+    // Step 2: Poll GET /invoke/v1/invoke/{invocation_id} for results
+    return await pollForInvokeResults({
+        fetch,
+        baseUrl,
+        invocationId,
+        authHeader,
+    });
+}
+async function pollForInvokeResults(options) {
+    const { fetch, baseUrl, invocationId, authHeader } = options;
+    let delay = 50; // Start with 50ms
+    const maxDelay = 1000; // Cap at 1 second
+    const maxAttempts = 30; // Maximum number of polling attempts
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        const pollUrl = `${baseUrl}/api/invoke/v1/invoke/${invocationId}`;
+        const response = await fetch(pollUrl, {
+            headers: {
+                Authorization: authHeader,
+            },
+        });
+        if (response.status === 200) {
+            // Action completed
+            const result = await response.json();
+            return result.results || result;
+        }
+        else if (response.status === 202) {
+            // Still processing, wait and try again
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            delay = Math.min(delay * 2, maxDelay); // Double delay up to max
+            continue;
+        }
+        else {
+            // Error occurred
+            throw new Error(`Failed to fetch action results: GET ${pollUrl} - ${response.status} ${response.statusText}`);
+        }
+    }
+    throw new Error(`Action execution timed out after ${maxAttempts} attempts`);
+}
+function generateRequestId() {
+    return Math.random().toString(36).substring(2) + Date.now().toString(36);
+}
+function getAuthorizationHeader(token) {
+    // Check if token is a JWT (has 3 parts separated by dots)
+    if (isJwt(token)) {
+        return `JWT ${token}`;
+    }
+    // Default to Bearer for other token types
+    return `Bearer ${token}`;
+}
+function isJwt(token) {
+    // JWT tokens have exactly 3 parts separated by dots
+    const parts = token.split(".");
+    if (parts.length !== 3) {
+        return false;
+    }
+    // Each part should be base64url encoded (no padding)
+    // Basic validation - each part should be non-empty and contain valid base64url characters
+    const base64urlPattern = /^[A-Za-z0-9_-]+$/;
+    return parts.every((part) => part.length > 0 && base64urlPattern.test(part));
+}
+function createDebugLogger(enabled) {
+    if (!enabled) {
+        return () => { }; // No-op function when debug is disabled
+    }
+    return (message, data) => {
+        const timestamp = new Date().toISOString();
+        if (data) {
+            console.log(`[${timestamp}] Zapier SDK: ${message}`, data);
+        }
+        else {
+            console.log(`[${timestamp}] Zapier SDK: ${message}`);
+        }
+    };
+}
+function createDebugFetch(options) {
+    const { originalFetch, debugLog } = options;
+    return async (input, options) => {
+        const startTime = Date.now();
+        // Convert input to URL string for logging
+        const urlString = input instanceof URL
+            ? input.toString()
+            : typeof input === "string"
+                ? input
+                : input.url;
+        // Log request
+        const requestInfo = {
+            method: options?.method || "GET",
+            url: urlString,
+            headers: options?.headers
+                ? maskSensitiveHeaders(options.headers)
+                : undefined,
+            hasBody: !!options?.body,
+        };
+        debugLog("📤 HTTP Request", requestInfo);
+        try {
+            const response = await originalFetch(input, options);
+            const duration = Date.now() - startTime;
+            // Log response
+            debugLog("📥 HTTP Response", {
+                status: response.status,
+                statusText: response.statusText,
+                ok: response.ok,
+                duration: `${duration}ms`,
+                url: urlString,
+            });
+            return response;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            debugLog("❌ HTTP Error", {
+                error: error instanceof Error ? error.message : "Unknown error",
+                duration: `${duration}ms`,
+                url: urlString,
+            });
+            throw error;
+        }
+    };
+}
+function maskSensitiveHeaders(headers) {
+    const maskedHeaders = {};
+    if (headers instanceof Headers) {
+        headers.forEach((value, key) => {
+            maskedHeaders[key] =
+                key.toLowerCase() === "authorization" ? maskToken(value) : value;
+        });
+    }
+    else if (Array.isArray(headers)) {
+        headers.forEach(([key, value]) => {
+            maskedHeaders[key] =
+                key.toLowerCase() === "authorization" ? maskToken(value) : value;
+        });
+    }
+    else {
+        Object.entries(headers).forEach(([key, value]) => {
+            maskedHeaders[key] =
+                key.toLowerCase() === "authorization" ? maskToken(value) : value;
+        });
+    }
+    return maskedHeaders;
+}
+function maskToken(token) {
+    if (token.length <= 8) {
+        return "***";
+    }
+    // Show first 4 and last 4 characters, mask the middle
+    const start = token.substring(0, 4);
+    const end = token.substring(token.length - 4);
+    const middle = "*".repeat(Math.min(token.length - 8, 20)); // Cap mask length
+    return `${start}${middle}${end}`;
+}
+async function generateTypes(options, sdk) {
+    const { appKey, authId, output = `./types/${appKey}.d.ts` } = options;
+    // Parse app identifier (support app@version format)
+    const { app, version } = parseAppIdentifier(appKey);
+    // Fetch all actions for the app
+    const actions = await sdk.actions.list({ appKey: app });
+    if (actions.length === 0) {
+        const typeDefinitions = generateEmptyTypesFile(app, version);
+        if (output) {
+            const fs = await Promise.resolve().then(() => __importStar(require("fs")));
+            const path = await Promise.resolve().then(() => __importStar(require("path")));
+            fs.mkdirSync(path.dirname(output), { recursive: true });
+            fs.writeFileSync(output, typeDefinitions, "utf8");
+        }
+        return typeDefinitions;
+    }
+    // Fetch input fields for each action
+    const actionsWithFields = [];
+    if (authId) {
+        for (const action of actions) {
+            try {
+                const fields = await sdk.fields.list({
+                    app: action.appKey,
+                    action: action.key,
+                    type: action.type,
+                    authId: authId,
+                });
+                actionsWithFields.push({ ...action, inputFields: fields });
+            }
+            catch {
+                // If we can't get fields for an action, include it without fields
+                actionsWithFields.push({ ...action, inputFields: [] });
+            }
+        }
+    }
+    else {
+        // Convert actions to have empty input fields (will generate generic types)
+        actions.forEach((action) => {
+            actionsWithFields.push({ ...action, inputFields: [] });
+        });
+    }
+    // Generate TypeScript types
+    const typeDefinitions = generateTypeDefinitions(app, actionsWithFields, version);
+    // Write to file if output path specified
+    if (output) {
+        const fs = await Promise.resolve().then(() => __importStar(require("fs")));
+        const path = await Promise.resolve().then(() => __importStar(require("path")));
+        fs.mkdirSync(path.dirname(output), { recursive: true });
+        fs.writeFileSync(output, typeDefinitions, "utf8");
+    }
+    return typeDefinitions;
+}
+function parseAppIdentifier(identifier) {
+    const parts = identifier.split("@");
+    return {
+        app: parts[0],
+        version: parts[1],
+    };
+}
+function generateTypeDefinitions(appKey, actions, version) {
+    // Handle empty actions
+    if (actions.length === 0) {
+        return generateEmptyTypesFile(appKey, version);
+    }
+    // Group actions by type
+    const actionsByType = actions.reduce((acc, action) => {
+        if (!acc[action.type]) {
+            acc[action.type] = [];
+        }
+        acc[action.type].push(action);
+        return acc;
+    }, {});
+    const appName = capitalize(appKey);
+    const versionComment = version
+        ? ` * Generated for ${appKey}@${version}`
+        : ` * Generated for ${appKey}`;
+    let output = `/* eslint-disable @typescript-eslint/naming-convention */
+/**
+ * Auto-generated TypeScript types for Zapier ${appKey} actions
+${versionComment}
+ * Generated on: ${new Date().toISOString()}
+ * 
+ * Usage:
+ *   import type { ${appName}Actions } from './path/to/this/file'
+ *   const sdk: ActionsSdk & { actions: ${appName}Actions } = createActionsSdk(...)
+ */
+
+import type { ActionExecutionOptions, ActionExecutionResult } from '@zapier/zapier-sdk'
+
+`;
+    // Generate input types for each action
+    actions.forEach((action) => {
+        if (action.inputFields.length > 0) {
+            const inputTypeName = `${appName}${capitalize(action.type)}${capitalize(sanitizeActionName(action.key))}Inputs`;
+            output += `interface ${inputTypeName} {\n`;
+            action.inputFields.forEach((field) => {
+                const isOptional = !field.required;
+                const fieldType = mapFieldTypeToTypeScript(field);
+                const description = field.helpText
+                    ? `  /** ${escapeComment(field.helpText)} */\n`
+                    : "";
+                output += `${description}  ${sanitizeFieldName(field.key)}${isOptional ? "?" : ""}: ${fieldType}\n`;
+            });
+            output += `}\n\n`;
+        }
+    });
+    // Generate action type interfaces for each action type
+    Object.entries(actionsByType).forEach(([actionType, typeActions]) => {
+        const typeName = `${appName}${capitalize(actionType)}Actions`;
+        output += `interface ${typeName} {\n`;
+        typeActions.forEach((action) => {
+            const actionName = sanitizeActionName(action.key);
+            const description = action.description
+                ? `  /** ${escapeComment(action.description)} */\n`
+                : "";
+            // Generate type-safe action method signature
+            if (action.inputFields.length > 0) {
+                const inputTypeName = `${appName}${capitalize(action.type)}${capitalize(sanitizeActionName(action.key))}Inputs`;
+                output += `${description}  ${actionName}: (options: { inputs: ${inputTypeName} } & Omit<ActionExecutionOptions, 'inputs'>) => Promise<ActionExecutionResult>\n`;
+            }
+            else {
+                // No specific input fields available - use generic Record<string, any> for inputs
+                output += `${description}  ${actionName}: (options?: { inputs?: Record<string, any> } & ActionExecutionOptions) => Promise<ActionExecutionResult>\n`;
+            }
+        });
+        output += `}\n\n`;
+    });
+    // Generate the main app actions interface
+    output += `export interface ${appName}Actions {\n`;
+    output += `  run: {\n`;
+    output += `    ${appKey}: {\n`;
+    Object.keys(actionsByType).forEach((actionType) => {
+        const typeName = `${appName}${capitalize(actionType)}Actions`;
+        output += `      ${actionType}: ${typeName}\n`;
+    });
+    output += `    }\n`;
+    output += `  }\n`;
+    output += `}\n`;
+    return output;
+}
+function generateEmptyTypesFile(appKey, version) {
+    const appName = capitalize(appKey);
+    const versionComment = version
+        ? ` * Generated for ${appKey}@${version}`
+        : ` * Generated for ${appKey}`;
+    return `/* eslint-disable @typescript-eslint/naming-convention */
+/**
+ * Auto-generated TypeScript types for Zapier ${appKey} actions
+${versionComment}
+ * Generated on: ${new Date().toISOString()}
+ * 
+ * No actions found for this app.
+ */
+
+import type { ActionExecutionOptions, ActionExecutionResult } from '@zapier/zapier-sdk'
+
+export interface ${appName}Actions {
+  run: {
+    ${appKey}: {
+      // No actions available
+    }
+  }
+}
+`;
+}
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1).replace(/[-_]/g, "");
+}
+function sanitizeActionName(actionKey) {
+    // Ensure the action name is a valid TypeScript identifier
+    return actionKey.replace(/[^a-zA-Z0-9_$]/g, "_");
+}
+function sanitizeFieldName(fieldKey) {
+    // Ensure the field name is a valid TypeScript identifier
+    return fieldKey.replace(/[^a-zA-Z0-9_$]/g, "_");
+}
+function escapeComment(comment) {
+    // Escape comment text to prevent breaking the JSDoc comment
+    return comment.replace(/\*\//g, "*\\/").replace(/\r?\n/g, " ");
+}
+function mapFieldTypeToTypeScript(field) {
+    // Handle choices (enum-like fields)
+    if (field.choices && field.choices.length > 0) {
+        const choiceValues = field.choices
+            .filter((choice) => choice.value !== undefined &&
+            choice.value !== null &&
+            choice.value !== "")
+            .map((choice) => typeof choice.value === "string" ? `"${choice.value}"` : choice.value);
+        if (choiceValues.length > 0) {
+            return choiceValues.join(" | ");
+        }
+        // If all choices were filtered out, fall through to default type handling
+    }
+    // Map Zapier field types to TypeScript types
+    switch (field.type?.toLowerCase()) {
+        case "string":
+        case "text":
+        case "email":
+        case "url":
+        case "password":
+            return "string";
+        case "integer":
+        case "number":
+            return "number";
+        case "boolean":
+            return "boolean";
+        case "datetime":
+        case "date":
+            return "string"; // ISO date strings
+        case "file":
+            return "string"; // File URL or content
+        case "array":
+            return "any[]";
+        case "object":
+            return "Record<string, any>";
+        default:
+            // Default to string for unknown types, with union for common cases
+            return "string | number | boolean";
+    }
+}
+// ============================================================================
+// Bundle Implementation
+// ============================================================================
+async function bundleCode(options) {
+    const { input, output, target = "es2020", cjs = false, minify = false, string: returnString = false, } = options;
+    // Dynamically import esbuild
+    const { buildSync } = await Promise.resolve().then(() => __importStar(require("esbuild")));
+    const fs = await Promise.resolve().then(() => __importStar(require("fs")));
+    const path = await Promise.resolve().then(() => __importStar(require("path")));
+    // Resolve input path
+    const resolvedInput = path.resolve(process.cwd(), input);
+    try {
+        // Bundle with esbuild
+        const result = buildSync({
+            entryPoints: [resolvedInput],
+            bundle: true,
+            platform: "node",
+            target: target,
+            format: cjs ? "cjs" : "esm",
+            minify: minify,
+            write: false,
+            external: [], // Bundle everything
+            banner: {
+                js: "#!/usr/bin/env node",
+            },
+        });
+        if (result.errors.length > 0) {
+            throw new Error(`Bundle failed: ${result.errors.map((e) => e.text).join(", ")}`);
+        }
+        const bundledCode = result.outputFiles?.[0]?.text;
+        if (!bundledCode) {
+            throw new Error("No output generated");
+        }
+        let finalOutput = bundledCode;
+        if (returnString) {
+            // Output as quoted string for node -e using JSON.stringify
+            finalOutput = JSON.stringify(bundledCode);
+        }
+        // Write to file if output path specified
+        if (output) {
+            fs.mkdirSync(path.dirname(output), { recursive: true });
+            fs.writeFileSync(output, finalOutput, "utf8");
+        }
+        return finalOutput;
+    }
+    catch (error) {
+        throw new Error(`Bundle failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+}