@zapier/zapier-sdk-cli 0.18.3 → 0.21.0

package/dist/src/generators/ast-generator.js

@@ -1,409 +0,0 @@
-import * as ts from "typescript";
-import { toSnakeCase, batch } from "@zapier/zapier-sdk";
-/**
- * AST-based TypeScript type generator using the TypeScript Compiler API
- */
-export class AstTypeGenerator {
-    constructor() {
-        this.factory = ts.factory;
-        this.printer = ts.createPrinter({
-            newLine: ts.NewLineKind.LineFeed,
-            removeComments: false,
-            omitTrailingSemicolon: false,
-        });
-    }
-    /**
-     * Generate TypeScript types using AST for a specific app
-     */
-    async generateTypes(options) {
-        const { app, authenticationId, sdk } = options;
-        // Fetch all actions for the app using implementation_id for correct versioning
-        const actionsResult = await sdk.listActions({
-            appKey: app.implementation_id,
-        });
-        const actions = actionsResult.data;
-        // Fetch input fields for each action
-        const actionsWithFields = [];
-        // Fetch all input fields with concurrency limiting for better reliability
-        // Using batch() instead of Promise.allSettled() prevents overwhelming the API
-        // and triggering rate limits when apps have many actions
-        const inputFieldsTasks = actions.map((action) => () => sdk.listInputFields({
-            appKey: app.implementation_id,
-            actionKey: action.key,
-            actionType: action.action_type,
-            authenticationId: authenticationId,
-        }));
-        const results = await batch(inputFieldsTasks, {
-            concurrency: 50, // Limit to 50 concurrent requests
-            retry: true, // Automatically retry transient failures
-            timeoutMs: 180000, // 3 minute overall timeout
-            taskTimeoutMs: 30000, // 30 seconds per-task timeout (API calls shouldn't take longer)
-        });
-        const failedActions = [];
-        results.forEach((result, i) => {
-            const action = actions[i];
-            if (result.status === "fulfilled") {
-                actionsWithFields.push({
-                    ...action,
-                    inputFields: result.value.data,
-                    name: action.title || action.key,
-                });
-            }
-            else {
-                failedActions.push(`${action.key} (${action.action_type}): ${result.reason?.message || "Unknown error"}`);
-                actionsWithFields.push({
-                    ...action,
-                    inputFields: [],
-                    name: action.title || action.key,
-                    app_key: action.app_key || app.implementation_id,
-                    action_type: action.action_type || "write",
-                    title: action.title || action.key,
-                    type: "action",
-                    description: action.description || "",
-                });
-            }
-        });
-        if (failedActions.length > 0) {
-            console.warn(`Failed to fetch input fields for ${failedActions.length} action(s):`);
-            failedActions.forEach((failedAction) => {
-                console.warn(`  - ${failedAction}`);
-            });
-        }
-        // Generate TypeScript AST nodes
-        const sourceFile = this.createSourceFile(app, actionsWithFields);
-        // Print the AST to string
-        return this.printer.printFile(sourceFile);
-    }
-    createSourceFile(app, actions) {
-        const appName = this.getPreferredAppName(app);
-        const versionComment = ` * Generated for ${app.implementation_id}`;
-        const preferredKey = this.getPreferredProgrammaticKey(app);
-        const myVariableName = `my${appName}`;
-        // Create header comment
-        const headerComment = `Auto-generated TypeScript types for Zapier ${app.key} actions
-${versionComment.slice(3)}
-Generated on: ${new Date().toISOString()}
-
-This file automatically augments the base SDK types when present.
-No manual imports or type casting required.
-
-Usage:
-  import { createZapierSdk } from "@zapier/zapier-sdk";
-  
-  const zapier = createZapierSdk();
-  // Types are automatically available:
-  await zapier.apps.${preferredKey}.search.user_by_email({ authenticationId: 123, inputs: { email } })
-  
-  // Factory usage (pinned auth):
-  const ${myVariableName} = zapier.apps.${preferredKey}({ authenticationId: 123 })
-  await ${myVariableName}.search.user_by_email({ inputs: { email } })`;
-        const statements = [
-            // Import the SDK to activate module augmentation
-            this.createImportStatement(["@zapier/zapier-sdk"]),
-            // Import types we'll use
-            this.createTypeImportStatement([
-                "ActionExecutionOptions",
-                "ActionExecutionResult",
-                "ZapierFetchInitOptions",
-            ], "@zapier/zapier-sdk"),
-        ];
-        // Group actions by type
-        const actionsByType = this.groupActionsByType(actions);
-        // Generate input interfaces for each action
-        actions.forEach((action) => {
-            if (action.inputFields.length > 0) {
-                const inputInterface = this.createInputInterface(appName, action);
-                statements.push(inputInterface);
-            }
-        });
-        // Generate action type interfaces
-        Object.entries(actionsByType).forEach(([actionType, typeActions]) => {
-            const actionInterface = this.createActionInterface(appName, actionType, typeActions);
-            statements.push(actionInterface);
-        });
-        // Generate app proxy interface
-        const appProxyInterface = this.createAppProxyInterface(appName, actionsByType);
-        statements.push(appProxyInterface);
-        // Generate app factory interface
-        const appFactoryInterface = this.createAppFactoryInterface(appName);
-        statements.push(appFactoryInterface);
-        // Generate combined app type
-        const appWithFactoryType = this.createAppWithFactoryType(appName);
-        statements.push(appWithFactoryType);
-        // Generate module augmentation for automatic type integration
-        const allKeys = this.getAllKeys(app);
-        const moduleAugmentation = this.createModuleAugmentation(allKeys, appName);
-        statements.push(moduleAugmentation);
-        // Add empty export to make this a module
-        statements.push(this.factory.createExportDeclaration(undefined, false, this.factory.createNamedExports([])));
-        // Create source file
-        const sourceFile = ts.createSourceFile("generated.d.ts", "", ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
-        // Add the header comment and ESLint disable as leading trivia to the first statement
-        if (statements.length > 0) {
-            // Add ESLint disable comment
-            ts.addSyntheticLeadingComment(statements[0], ts.SyntaxKind.MultiLineCommentTrivia, " eslint-disable @typescript-eslint/naming-convention, @typescript-eslint/no-explicit-any ", true);
-            // Add header comment
-            ts.addSyntheticLeadingComment(statements[0], ts.SyntaxKind.MultiLineCommentTrivia, headerComment, true);
-        }
-        return this.factory.updateSourceFile(sourceFile, statements);
-    }
-    createImportStatement(imports, from) {
-        // Handle side-effect only import (no imports, just the module path)
-        if (imports.length === 1 && !from && imports[0].startsWith("@")) {
-            return this.factory.createImportDeclaration(undefined, undefined, this.factory.createStringLiteral(imports[0]), undefined);
-        }
-        const fromModule = from || imports[0];
-        const importNames = from ? imports : [];
-        return this.factory.createImportDeclaration(undefined, importNames.length > 0
-            ? this.factory.createImportClause(false, undefined, this.factory.createNamedImports(importNames.map((name) => this.factory.createImportSpecifier(false, undefined, this.factory.createIdentifier(name)))))
-            : undefined, this.factory.createStringLiteral(fromModule), undefined);
-    }
-    createTypeImportStatement(imports, from) {
-        return this.factory.createImportDeclaration(undefined, this.factory.createImportClause(true, // typeOnly: true
-        undefined, this.factory.createNamedImports(imports.map((name) => this.factory.createImportSpecifier(false, undefined, this.factory.createIdentifier(name))))), this.factory.createStringLiteral(from), undefined);
-    }
-    groupActionsByType(actions) {
-        return actions.reduce((acc, action) => {
-            if (!acc[action.action_type]) {
-                acc[action.action_type] = [];
-            }
-            acc[action.action_type].push(action);
-            return acc;
-        }, {});
-    }
-    createInputInterface(appName, action) {
-        const inputTypeName = `${appName}${this.capitalize(action.action_type)}${this.capitalize(this.sanitizeActionName(action.key))}Inputs`;
-        const properties = action.inputFields.map((field) => {
-            const fieldType = this.mapFieldTypeToTypeNode(field);
-            const isOptional = !field.is_required;
-            let property = this.factory.createPropertySignature(undefined, this.sanitizeFieldName(field.key), isOptional
-                ? this.factory.createToken(ts.SyntaxKind.QuestionToken)
-                : undefined, fieldType);
-            // Add JSDoc comment if description exists
-            if (field.description) {
-                property = ts.addSyntheticLeadingComment(property, ts.SyntaxKind.MultiLineCommentTrivia, `* ${this.escapeComment(field.description)} `, true);
-            }
-            return property;
-        });
-        return this.factory.createInterfaceDeclaration(undefined, inputTypeName, undefined, undefined, properties);
-    }
-    createActionInterface(appName, actionType, typeActions) {
-        const typeName = `${appName}${this.capitalize(actionType)}Actions`;
-        const methods = typeActions.map((action) => {
-            const actionName = this.sanitizeActionName(action.key);
-            let methodSignature;
-            if (action.inputFields.length > 0) {
-                // Generate type-safe action method signature
-                const inputTypeName = `${appName}${this.capitalize(action.action_type)}${this.capitalize(this.sanitizeActionName(action.key))}Inputs`;
-                const inputsType = this.factory.createTypeLiteralNode([
-                    this.factory.createPropertySignature(undefined, "inputs", undefined, this.factory.createTypeReferenceNode(inputTypeName)),
-                ]);
-                const omitType = this.factory.createTypeReferenceNode("Omit", [
-                    this.factory.createTypeReferenceNode("ActionExecutionOptions"),
-                    this.factory.createLiteralTypeNode(this.factory.createStringLiteral("inputs")),
-                ]);
-                const optionsType = this.factory.createIntersectionTypeNode([
-                    inputsType,
-                    omitType,
-                ]);
-                methodSignature = this.factory.createMethodSignature(undefined, actionName, undefined, undefined, [
-                    this.factory.createParameterDeclaration(undefined, undefined, "options", undefined, optionsType),
-                ], this.factory.createTypeReferenceNode("Promise", [
-                    this.factory.createTypeReferenceNode("ActionExecutionResult"),
-                ]));
-            }
-            else {
-                // No specific input fields available - use generic Record<string, any> for inputs
-                const genericInputsType = this.factory.createTypeLiteralNode([
-                    this.factory.createPropertySignature(undefined, "inputs", this.factory.createToken(ts.SyntaxKind.QuestionToken), this.factory.createTypeReferenceNode("Record", [
-                        this.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
-                        this.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
-                    ])),
-                ]);
-                const intersectionType = this.factory.createIntersectionTypeNode([
-                    genericInputsType,
-                    this.factory.createTypeReferenceNode("ActionExecutionOptions"),
-                ]);
-                methodSignature = this.factory.createMethodSignature(undefined, actionName, undefined, undefined, [
-                    this.factory.createParameterDeclaration(undefined, undefined, "options", this.factory.createToken(ts.SyntaxKind.QuestionToken), intersectionType),
-                ], this.factory.createTypeReferenceNode("Promise", [
-                    this.factory.createTypeReferenceNode("ActionExecutionResult"),
-                ]));
-            }
-            // Add JSDoc comment if description exists
-            if (action.description) {
-                methodSignature = ts.addSyntheticLeadingComment(methodSignature, ts.SyntaxKind.MultiLineCommentTrivia, `* ${this.escapeComment(action.description)} `, true);
-            }
-            return methodSignature;
-        });
-        return this.factory.createInterfaceDeclaration(undefined, typeName, undefined, undefined, methods);
-    }
-    createAppProxyInterface(appName, actionsByType) {
-        const properties = [
-            ...Object.keys(actionsByType).map((actionType) => this.factory.createPropertySignature(undefined, actionType, undefined, this.factory.createTypeReferenceNode(`${appName}${this.capitalize(actionType)}Actions`))),
-            // Always include fetch method for authenticated HTTP requests
-            this.createFetchMethodProperty(),
-        ];
-        return this.factory.createInterfaceDeclaration(undefined, `${appName}AppProxy`, undefined, undefined, properties);
-    }
-    createFetchMethodProperty() {
-        let property = this.factory.createPropertySignature(undefined, "fetch", undefined, this.factory.createFunctionTypeNode(undefined, [
-            this.factory.createParameterDeclaration(undefined, undefined, "url", undefined, this.factory.createUnionTypeNode([
-                this.factory.createTypeReferenceNode("string"),
-                this.factory.createTypeReferenceNode("URL"),
-            ])),
-            this.factory.createParameterDeclaration(undefined, undefined, "init", this.factory.createToken(ts.SyntaxKind.QuestionToken), this.factory.createTypeReferenceNode("ZapierFetchInitOptions")),
-        ], this.factory.createTypeReferenceNode("Promise", [
-            this.factory.createTypeReferenceNode("Response"),
-        ])));
-        // Add JSDoc comment
-        property = ts.addSyntheticLeadingComment(property, ts.SyntaxKind.MultiLineCommentTrivia, "* Make authenticated HTTP requests through Zapier's Relay service ", true);
-        return property;
-    }
-    createAppFactoryInterface(appName) {
-        const callSignature = this.factory.createCallSignature(undefined, [
-            this.factory.createParameterDeclaration(undefined, undefined, "options", undefined, this.factory.createTypeLiteralNode([
-                this.factory.createPropertySignature(undefined, "authenticationId", undefined, this.factory.createUnionTypeNode([
-                    this.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
-                    this.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
-                ])),
-            ])),
-        ], this.factory.createTypeReferenceNode(`${appName}AppProxy`));
-        return this.factory.createInterfaceDeclaration(undefined, `${appName}AppFactory`, undefined, undefined, [callSignature]);
-    }
-    createAppWithFactoryType(appName) {
-        return this.factory.createTypeAliasDeclaration(undefined, `${appName}AppWithFactory`, undefined, this.factory.createIntersectionTypeNode([
-            this.factory.createTypeReferenceNode(`${appName}AppFactory`),
-            this.factory.createTypeReferenceNode(`${appName}AppProxy`),
-        ]));
-    }
-    createModuleAugmentation(appKeys, appName) {
-        // Create: declare module "@zapier/zapier-sdk" { interface ZapierSdkApps { [appKey]: AppWithFactory } }
-        // This creates a new interface that we can merge with ZapierSdk
-        // Create properties for all keys (main key + other_keys)
-        const properties = appKeys.map((appKey) => this.factory.createPropertySignature(undefined, this.createPropertyName(appKey), undefined, this.factory.createTypeReferenceNode(`${appName}AppWithFactory`)));
-        return this.factory.createModuleDeclaration([this.factory.createToken(ts.SyntaxKind.DeclareKeyword)], this.factory.createStringLiteral("@zapier/zapier-sdk"), this.factory.createModuleBlock([
-            this.factory.createInterfaceDeclaration(undefined, "ZapierSdkApps", undefined, undefined, properties),
-        ]));
-    }
-    mapFieldTypeToTypeNode(field) {
-        // TODO: Handle choices when needed - choices are handled separately through listInputFieldChoices
-        // Map Zapier field types to TypeScript types
-        // Handle the new enum types from InputFieldItem.value_type
-        switch (field.value_type?.toLowerCase()) {
-            case "string":
-            case "text":
-            case "email":
-            case "url":
-            case "password":
-            case "datetime":
-            case "date":
-            case "file":
-                return this.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword);
-            case "integer":
-            case "number":
-                return this.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
-            case "boolean":
-                return this.factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword);
-            case "array":
-                return this.factory.createArrayTypeNode(this.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword));
-            case "object":
-                return this.factory.createTypeReferenceNode("Record", [
-                    this.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
-                    this.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
-                ]);
-            default:
-                // Default to string | number | boolean for unknown types
-                return this.factory.createUnionTypeNode([
-                    this.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
-                    this.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
-                    this.factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword),
-                ]);
-        }
-    }
-    capitalize(str) {
-        return str.charAt(0).toUpperCase() + str.slice(1).replace(/[-_]/g, "");
-    }
-    sanitizeActionName(actionKey) {
-        // Ensure the action name is a valid TypeScript identifier
-        let sanitized = actionKey.replace(/[^a-zA-Z0-9_$]/g, "_");
-        // If it starts with a number, prepend an underscore
-        if (/^[0-9]/.test(sanitized)) {
-            sanitized = "_" + sanitized;
-        }
-        return sanitized;
-    }
-    sanitizeFieldName(fieldKey) {
-        // Ensure the field name is a valid TypeScript identifier
-        let sanitized = fieldKey.replace(/[^a-zA-Z0-9_$]/g, "_");
-        // If it starts with a number, prepend an underscore
-        if (/^[0-9]/.test(sanitized)) {
-            sanitized = "_" + sanitized;
-        }
-        return sanitized;
-    }
-    escapeComment(comment) {
-        // Escape comment text to prevent breaking the JSDoc comment
-        return comment.replace(/\*\//g, "*\\/").replace(/\r?\n/g, " ");
-    }
-    createPropertyName(name) {
-        // Check if the name is a valid JavaScript identifier
-        if (this.isValidIdentifier(name)) {
-            return this.factory.createIdentifier(name);
-        }
-        else {
-            // Use string literal for invalid identifiers (e.g., contains dashes)
-            return this.factory.createStringLiteral(name);
-        }
-    }
-    isValidIdentifier(name) {
-        // JavaScript identifier rules: must start with letter, $, or _,
-        // followed by letters, digits, $, or _
-        return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
-    }
-    getPreferredProgrammaticKey(app) {
-        // If we have a slug, convert it to snake_case as the preferred programmatic key
-        if (app.slug) {
-            const snakeCaseSlug = toSnakeCase(app.slug);
-            if (this.isValidIdentifier(snakeCaseSlug)) {
-                return snakeCaseSlug;
-            }
-        }
-        // Otherwise, use the main key if it's a valid identifier
-        if (this.isValidIdentifier(app.key)) {
-            return app.key;
-        }
-        // Fallback: sanitize the key to make it a valid identifier
-        return this.sanitizeToIdentifier(app.key);
-    }
-    getPreferredAppName(app) {
-        const preferredKey = this.getPreferredProgrammaticKey(app);
-        // If it's snake_case, convert to PascalCase
-        if (preferredKey.includes("_")) {
-            return preferredKey
-                .split("_")
-                .map((word) => this.capitalize(word.toLowerCase()))
-                .join("");
-        }
-        // Otherwise, capitalize first letter for PascalCase
-        return this.capitalize(preferredKey);
-    }
-    sanitizeToIdentifier(name) {
-        // Convert any string to a valid JavaScript identifier
-        let sanitized = name.replace(/[^a-zA-Z0-9_$]/g, "_");
-        // If it starts with a number, prepend an underscore
-        if (/^[0-9]/.test(sanitized)) {
-            sanitized = "_" + sanitized;
-        }
-        return sanitized;
-    }
-    getAllKeys(app) {
-        // Return all possible keys for this app
-        const allKeys = new Set([app.key]);
-        if (app.slug) {
-            allKeys.add(app.slug);
-            allKeys.add(toSnakeCase(app.slug));
-        }
-        return Array.from(allKeys);
-    }
-}

package/dist/src/index.d.ts

@@ -1,4 +0,0 @@
-export { createZapierCliSdk, type ZapierCliSdkOptions } from "./sdk";
-export type { CliEventContext, CliCommandExecutedEventData, } from "./telemetry/builders";
-export { buildCliCommandExecutedEvent } from "./telemetry/builders";
-export type { CliCommandExecutedEvent } from "./telemetry/events";

package/dist/src/index.js

@@ -1,4 +0,0 @@
-// Main exports for the CLI package
-export { createZapierCliSdk } from "./sdk";
-export { buildCliCommandExecutedEvent } from "./telemetry/builders";
-// All CLI functionality is now schema-driven via generateCLICommands

package/dist/src/plugins/add/index.d.ts

@@ -1,15 +0,0 @@
-import type { Plugin, GetSdkType, ListActionsPluginProvides, ListAppsPluginProvides, ListInputFieldsPluginProvides, ListAuthenticationsPluginProvides } from "@zapier/zapier-sdk";
-import { AddSchema, type AddOptions } from "./schemas";
-import { type GenerateAppTypesPluginProvides } from "../generateAppTypes";
-import { type BuildManifestPluginProvides } from "../buildManifest";
-export interface AddPluginProvides {
-    add: (options: AddOptions) => Promise<void>;
-    context: {
-        meta: {
-            add: {
-                inputSchema: typeof AddSchema;
-            };
-        };
-    };
-}
-export declare const addPlugin: Plugin<GetSdkType<ListAppsPluginProvides & ListActionsPluginProvides & ListInputFieldsPluginProvides & ListAuthenticationsPluginProvides & BuildManifestPluginProvides & GenerateAppTypesPluginProvides>, {}, AddPluginProvides>;

package/dist/src/plugins/add/index.js

@@ -1,103 +0,0 @@
-import { createFunction } from "@zapier/zapier-sdk";
-import { AddSchema } from "./schemas";
-import { detectTypesOutputDirectory } from "../../utils/directory-detection";
-import { resolve } from "path";
-export const addPlugin = ({ sdk }) => {
-    const add = createFunction(async function add(options) {
-        const { appKeys, authenticationIds, configPath, typesOutput = await detectTypesOutputDirectory(), } = options;
-        const resolvedTypesOutput = resolve(typesOutput);
-        console.log(`📦 Adding ${appKeys.length} app(s)...`);
-        // Track app names for better console output
-        const appSlugAndKeyMap = new Map();
-        // Define progress handler for manifest building
-        const handleManifestProgress = (event) => {
-            switch (event.type) {
-                case "apps_lookup_start":
-                    console.log(`📦 Looking up ${event.count} app(s)...`);
-                    break;
-                case "app_found":
-                    // Store the app display name for later use
-                    const displayName = event.app.slug
-                        ? `${event.app.slug} (${event.app.key})`
-                        : event.app.key;
-                    appSlugAndKeyMap.set(event.app.key, displayName);
-                    break;
-                case "apps_lookup_complete":
-                    if (event.count === 0) {
-                        console.warn("⚠️ No apps found");
-                    }
-                    break;
-                case "app_processing_start":
-                    const appName = event.slug
-                        ? `${event.slug} (${event.appKey})`
-                        : event.appKey;
-                    console.log(`📦 Adding ${appName}...`);
-                    break;
-                case "manifest_updated":
-                    const appDisplay = appSlugAndKeyMap.get(event.appKey) || event.appKey;
-                    console.log(`📝 Locked ${appDisplay} to ${event.appKey}@${event.version} using key '${event.manifestKey}'`);
-                    break;
-                case "app_processing_error":
-                    const errorApp = appSlugAndKeyMap.get(event.appKey) || event.appKey;
-                    console.warn(`⚠️ ${event.error} for ${errorApp}`);
-                    break;
-            }
-        };
-        // Define progress handler for type generation
-        const handleTypesProgress = (event) => {
-            switch (event.type) {
-                case "authentications_lookup_start":
-                    console.log(`🔐 Looking up ${event.count} authentication(s)...`);
-                    break;
-                case "authentications_lookup_complete":
-                    console.log(`🔐 Found ${event.count} authentication(s)`);
-                    break;
-                case "authentication_matched":
-                    const appWithAuth = appSlugAndKeyMap.get(event.appKey) || event.appKey;
-                    console.log(`🔐 Using authentication ${event.authenticationId} (${event.authenticationTitle}) for ${appWithAuth}`);
-                    break;
-                case "authentication_not_matched":
-                    const appWithoutAuth = appSlugAndKeyMap.get(event.appKey) || event.appKey;
-                    console.warn(`⚠️ No matching authentication found for ${appWithoutAuth}`);
-                    break;
-                case "file_written":
-                    console.log(`🔧 Generated types for ${event.manifestKey} at ${event.filePath}`);
-                    break;
-                case "app_processing_error":
-                    const errorApp = appSlugAndKeyMap.get(event.appKey) || event.appKey;
-                    console.warn(`⚠️ ${event.error} for ${errorApp}`);
-                    break;
-            }
-        };
-        const manifestResult = await sdk.buildManifest({
-            appKeys,
-            skipWrite: false,
-            configPath,
-            onProgress: handleManifestProgress,
-        });
-        const typesResult = await sdk.generateAppTypes({
-            appKeys,
-            authenticationIds,
-            skipWrite: false,
-            typesOutputDirectory: resolvedTypesOutput,
-            onProgress: handleTypesProgress,
-        });
-        const results = manifestResult.manifest?.apps || {};
-        // Final summary
-        const successfulApps = Object.keys(results).filter((manifestKey) => typesResult.writtenFiles?.[manifestKey]);
-        if (successfulApps.length > 0) {
-            console.log(`✅ Added ${successfulApps.length} app(s) to manifest`);
-        }
-    }, AddSchema);
-    return {
-        add,
-        context: {
-            meta: {
-                add: {
-                    categories: ["utility"],
-                    inputSchema: AddSchema,
-                },
-            },
-        },
-    };
-};

package/dist/src/plugins/add/schemas.d.ts

@@ -1,8 +0,0 @@
-import { z } from "zod";
-export declare const AddSchema: z.ZodObject<{
-    appKeys: z.ZodArray<z.ZodString>;
-    authenticationIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    configPath: z.ZodOptional<z.ZodString>;
-    typesOutput: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type AddOptions = z.infer<typeof AddSchema>;

package/dist/src/plugins/add/schemas.js

@@ -1,22 +0,0 @@
-import { z } from "zod";
-import { DEFAULT_CONFIG_PATH } from "@zapier/zapier-sdk";
-export const AddSchema = z
-    .object({
-    appKeys: z
-        .array(z.string().min(1, "App key cannot be empty"))
-        .min(1, "At least one app key is required")
-        .describe("One or more app keys to add (e.g., 'slack', 'github', 'trello')"),
-    authenticationIds: z
-        .array(z.string())
-        .optional()
-        .describe("Authentication IDs to use for type generation (e.g., ['123', '456'])"),
-    configPath: z
-        .string()
-        .optional()
-        .describe(`Path to Zapier config file (defaults to '${DEFAULT_CONFIG_PATH}', e.g., './custom/.zapierrc')`),
-    typesOutput: z
-        .string()
-        .optional()
-        .describe("Directory for TypeScript type files (defaults to (src/lib/.)/zapier/apps/, e.g., './src/types/zapier/')"),
-})
-    .describe("Add apps with manifest locking and TypeScript type generation - updates .zapierrc with app versions and generates TypeScript definition files");

package/dist/src/plugins/buildManifest/index.d.ts

@@ -1,13 +0,0 @@
-import type { Plugin, GetSdkType, GetContextType, ListAppsPluginProvides, ManifestPluginProvides } from "@zapier/zapier-sdk";
-import { BuildManifestSchema, type BuildManifestOptions, type BuildManifestResult } from "./schemas";
-export interface BuildManifestPluginProvides {
-    buildManifest: (options: BuildManifestOptions) => Promise<BuildManifestResult>;
-    context: {
-        meta: {
-            buildManifest: {
-                inputSchema: typeof BuildManifestSchema;
-            };
-        };
-    };
-}
-export declare const buildManifestPlugin: Plugin<GetSdkType<ListAppsPluginProvides>, GetContextType<ManifestPluginProvides>, BuildManifestPluginProvides>;

package/dist/src/plugins/buildManifest/index.js

@@ -1,81 +0,0 @@
-import { createFunction, ZapierValidationError, ZapierUnknownError, } from "@zapier/zapier-sdk";
-import { BuildManifestSchema, } from "./schemas";
-import { createManifestEntry } from "../../utils/manifest-helpers";
-export const buildManifestPlugin = ({ sdk, context }) => {
-    const buildManifest = createFunction(async function buildManifest(options) {
-        const { appKeys, skipWrite = false, configPath, onProgress } = options;
-        // Get apps using listApps (which respects existing manifest for version locking)
-        onProgress?.({ type: "apps_lookup_start", count: appKeys.length });
-        const appsIterator = sdk.listApps({ appKeys }).items();
-        const apps = [];
-        for await (const app of appsIterator) {
-            apps.push(app);
-            onProgress?.({ type: "app_found", app });
-        }
-        onProgress?.({ type: "apps_lookup_complete", count: apps.length });
-        if (apps.length === 0) {
-            return {};
-        }
-        let updatedManifest;
-        // Process each app
-        for (const app of apps) {
-            onProgress?.({
-                type: "app_processing_start",
-                appKey: app.key,
-                slug: app.slug,
-            });
-            try {
-                const manifestEntry = createManifestEntry(app);
-                onProgress?.({
-                    type: "manifest_entry_built",
-                    appKey: app.key,
-                    manifestKey: manifestEntry.implementationName,
-                    version: manifestEntry.version || "",
-                });
-                const { key: updatedManifestKey, manifest } = await context.updateManifestEntry({
-                    appKey: app.key,
-                    entry: manifestEntry,
-                    configPath,
-                    skipWrite,
-                    manifest: updatedManifest,
-                });
-                updatedManifest = manifest;
-                onProgress?.({
-                    type: "manifest_updated",
-                    appKey: app.key,
-                    manifestKey: updatedManifestKey,
-                    version: manifestEntry.version || "",
-                });
-                onProgress?.({ type: "app_processing_complete", appKey: app.key });
-            }
-            catch (error) {
-                const errorMessage = `Failed to process app ${app.key}: ${error instanceof Error ? error.message : String(error)}`;
-                onProgress?.({
-                    type: "app_processing_error",
-                    appKey: app.key,
-                    error: errorMessage,
-                });
-                if (error instanceof ZapierValidationError) {
-                    throw error; // Preserve the specific error type
-                }
-                else {
-                    throw new ZapierUnknownError(errorMessage, {
-                        cause: error, // Works for both Error and non-Error
-                    });
-                }
-            }
-        }
-        return { manifest: updatedManifest };
-    }, BuildManifestSchema);
-    return {
-        buildManifest,
-        context: {
-            meta: {
-                buildManifest: {
-                    categories: ["utility"],
-                    inputSchema: BuildManifestSchema,
-                },
-            },
-        },
-    };
-};