@zapier/zapier-sdk-cli 0.8.4 → 0.9.0

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@zapier/zapier-sdk-cli",
-    "version": "0.8.4",
+    "version": "0.9.0",
     "description": "Command line interface for Zapier SDK",
     "main": "dist/index.cjs",
     "module": "dist/index.mjs",

package/dist/src/plugins/add/ast-generator.d.ts

@@ -0,0 +1,37 @@
+import type { GetSdkType, ListActionsPluginProvides, ListInputFieldsPluginProvides, ManifestPluginProvides } from "@zapier/zapier-sdk";
+interface GenerateTypesOptions {
+    appKey: string;
+    authenticationId?: number;
+}
+/**
+ * AST-based TypeScript type generator using the TypeScript Compiler API
+ */
+export declare class AstTypeGenerator {
+    private readonly factory;
+    private readonly printer;
+    /**
+     * Generate TypeScript types using AST for a specific app
+     */
+    generateTypes(options: GenerateTypesOptions & {
+        sdk: GetSdkType<ListActionsPluginProvides & ListInputFieldsPluginProvides & ManifestPluginProvides>;
+    }): Promise<string>;
+    private parseAppIdentifier;
+    private createSourceFile;
+    private createImportStatement;
+    private createTypeImportStatement;
+    private groupActionsByType;
+    private createInputInterface;
+    private createActionInterface;
+    private createAppProxyInterface;
+    private createFetchMethodProperty;
+    private createAppFactoryInterface;
+    private createAppWithFactoryType;
+    private createModuleAugmentation;
+    private mapFieldTypeToTypeNode;
+    private generateEmptyTypesFile;
+    private capitalize;
+    private sanitizeActionName;
+    private sanitizeFieldName;
+    private escapeComment;
+}
+export {};

package/dist/src/plugins/add/ast-generator.js

@@ -0,0 +1,403 @@
+import * as ts from "typescript";
+/**
+ * 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 { appKey, authenticationId, sdk } = options;
+        // Parse app identifier (support app@version format)
+        const { app, version } = this.parseAppIdentifier(appKey);
+        // Fetch all actions for the app
+        const actionsResult = await sdk.listActions({
+            appKey: app,
+        });
+        const actions = actionsResult.data;
+        if (actions.length === 0) {
+            return this.generateEmptyTypesFile(app, version);
+        }
+        // Fetch input fields for each action
+        const actionsWithFields = [];
+        if (authenticationId) {
+            for (const action of actions) {
+                try {
+                    const fieldsResult = await sdk.listInputFields({
+                        appKey: appKey,
+                        actionKey: action.key,
+                        actionType: action.action_type,
+                        authenticationId: authenticationId,
+                    });
+                    const fields = fieldsResult.data.map((field) => {
+                        const fieldObj = field;
+                        return {
+                            ...fieldObj,
+                            required: fieldObj.is_required || fieldObj.required || false,
+                        };
+                    });
+                    actionsWithFields.push({
+                        ...action,
+                        inputFields: fields,
+                        name: action.title || action.key,
+                    });
+                }
+                catch {
+                    // If we can't get fields for an action, include it without fields
+                    actionsWithFields.push({
+                        ...action,
+                        inputFields: [],
+                        name: action.title || action.key,
+                    });
+                }
+            }
+        }
+        else {
+            // Convert actions to have empty input fields (will generate generic types)
+            actions.forEach((action) => {
+                actionsWithFields.push({
+                    ...action,
+                    inputFields: [],
+                    name: action.title || action.key,
+                    app_key: action.app_key || appKey,
+                    action_type: action.action_type || "write",
+                    title: action.title || action.key,
+                    type: "action",
+                    description: action.description || "",
+                });
+            });
+        }
+        // Generate TypeScript AST nodes
+        const sourceFile = this.createSourceFile(app, actionsWithFields, version);
+        // Print the AST to string
+        return this.printer.printFile(sourceFile);
+    }
+    parseAppIdentifier(identifier) {
+        const parts = identifier.split("@");
+        return {
+            app: parts[0],
+            version: parts[1],
+        };
+    }
+    createSourceFile(appKey, actions, version) {
+        const appName = this.capitalize(appKey);
+        const versionComment = version
+            ? ` * Generated for ${appKey}@${version}`
+            : ` * Generated for ${appKey}`;
+        // Create header comment
+        const headerComment = `Auto-generated TypeScript types for Zapier ${appKey} 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.${appKey}.search.user_by_email({ authenticationId: 123, inputs: { email } })
+  
+  // Factory usage (pinned auth):
+  const my${appName} = zapier.apps.${appKey}({ authenticationId: 123 })
+  await my${appName}.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 moduleAugmentation = this.createModuleAugmentation(appKey, 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.required;
+            let property = this.factory.createPropertySignature(undefined, this.sanitizeFieldName(field.key), isOptional
+                ? this.factory.createToken(ts.SyntaxKind.QuestionToken)
+                : undefined, fieldType);
+            // Add JSDoc comment if helpText exists
+            if (field.helpText) {
+                property = ts.addSyntheticLeadingComment(property, ts.SyntaxKind.MultiLineCommentTrivia, `* ${this.escapeComment(field.helpText)} `, 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.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(appKey, appName) {
+        // Create: declare module "@zapier/zapier-sdk" { interface ZapierSdkApps { [appKey]: AppWithFactory } }
+        // This creates a new interface that we can merge with ZapierSdk
+        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, [
+                this.factory.createPropertySignature(undefined, appKey, undefined, this.factory.createTypeReferenceNode(`${appName}AppWithFactory`)),
+            ]),
+        ]));
+    }
+    mapFieldTypeToTypeNode(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"
+                ? this.factory.createLiteralTypeNode(this.factory.createStringLiteral(choice.value))
+                : this.factory.createLiteralTypeNode(this.factory.createNumericLiteral(String(choice.value))));
+            if (choiceValues.length > 0) {
+                return this.factory.createUnionTypeNode(choiceValues);
+            }
+        }
+        // Map Zapier field types to TypeScript types
+        switch (field.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),
+                ]);
+        }
+    }
+    generateEmptyTypesFile(appKey, version) {
+        const appName = this.capitalize(appKey);
+        const versionComment = version
+            ? ` * Generated for ${appKey}@${version}`
+            : ` * Generated for ${appKey}`;
+        return `/* eslint-disable @typescript-eslint/naming-convention, @typescript-eslint/no-explicit-any */
+/**
+ * Auto-generated TypeScript types for Zapier ${appKey} actions
+${versionComment}
+ * Generated on: ${new Date().toISOString()}
+ * 
+ * No actions found for this app.
+ */
+
+import type { ActionExecutionOptions, ActionExecutionResult, ZapierFetchInitOptions } from '@zapier/zapier-sdk'
+
+interface ${appName}AppProxy {
+  /** Make authenticated HTTP requests through Zapier's Relay service */
+  fetch: (url: string | URL, init?: ZapierFetchInitOptions) => Promise<Response>
+}
+
+interface ${appName}AppFactory {
+  (options: { authenticationId: number }): ${appName}AppProxy
+}
+
+type ${appName}AppWithFactory = ${appName}AppFactory & ${appName}AppProxy
+
+declare module "@zapier/zapier-sdk" {
+  interface ZapierSdkApps {
+    ${appKey}: ${appName}AppWithFactory
+  }
+}
+`;
+    }
+    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, " ");
+    }
+}

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

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

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

@@ -0,0 +1,122 @@
+import { createFunction } from "@zapier/zapier-sdk";
+import { AddSchema } from "./schemas";
+import { AstTypeGenerator } from "./ast-generator";
+import { mkdir, access, writeFile } from "fs/promises";
+import { resolve, join } from "path";
+/**
+ * Detect the best default directory for TypeScript types
+ * Looks for src or lib directories, falls back to current directory
+ */
+async function detectTypesOutputDirectory() {
+    // Check for common source directories in priority order
+    const candidates = ["src", "lib"];
+    for (const candidate of candidates) {
+        try {
+            await access(candidate);
+            return join(candidate, "zapier", "apps");
+        }
+        catch {
+            // Directory doesn't exist, continue to next candidate
+        }
+    }
+    // Fall back to current directory
+    return "./zapier/apps/";
+}
+export const addPlugin = ({ sdk, context }) => {
+    const add = createFunction(async function add(options) {
+        const { appKeys, authenticationIds, configPath, typesOutput = await detectTypesOutputDirectory(), } = options;
+        const resolvedTypesOutput = resolve(typesOutput);
+        // Ensure types output directory exists
+        await mkdir(resolvedTypesOutput, { recursive: true });
+        // Get apps using listApps (which respects existing manifest for version locking)
+        console.log(`📦 Looking up ${appKeys.length} app(s)...`);
+        const appsIterator = sdk.listApps({ appKeys }).items();
+        const apps = [];
+        for await (const app of appsIterator) {
+            apps.push(app);
+        }
+        if (apps.length === 0) {
+            console.warn("⚠️ No apps found");
+            return;
+        }
+        // Fetch authentications if provided
+        let authentications = [];
+        if (authenticationIds && authenticationIds.length > 0) {
+            console.log(`🔐 Looking up ${authenticationIds.length} authentication(s)...`);
+            const authsIterator = sdk
+                .listAuthentications({ authenticationIds })
+                .items();
+            for await (const auth of authsIterator) {
+                authentications.push(auth);
+            }
+            console.log(`🔐 Found ${authentications.length} authentication(s)`);
+        }
+        // Process each app
+        for (const app of apps) {
+            console.log(`📦 Adding ${app.key}...`);
+            try {
+                // Extract implementation name and version from current_implementation_id
+                const currentImplementationId = app.current_implementation_id;
+                const [implementationName, version] = currentImplementationId.split("@");
+                if (!implementationName || !version) {
+                    console.warn(`⚠️ Invalid implementation ID format for '${app.key}': ${currentImplementationId}. Expected format: <implementationName>@<version>. Skipping...`);
+                    continue;
+                }
+                // Update manifest using manifest plugin's function
+                const [manifestKey] = await context.updateManifestEntry(app.key, {
+                    implementationName,
+                    version,
+                }, configPath);
+                console.log(`📝 Locked ${app.key} to ${implementationName}@${version} using key '${manifestKey}'`);
+                // Find matching authentication for this app if authentications were provided
+                let authenticationId;
+                if (authentications.length > 0) {
+                    // Match authentication by app_key
+                    const matchingAuth = authentications.find((auth) => {
+                        return auth.app_key === app.key;
+                    });
+                    if (matchingAuth) {
+                        authenticationId = matchingAuth.id;
+                        console.log(`🔐 Using authentication ${authenticationId} (${matchingAuth.title}) for ${app.key}`);
+                    }
+                    else {
+                        console.warn(`⚠️ No matching authentication found for ${app.key}`);
+                    }
+                }
+                // Generate types using the manifest key for consistency
+                const typesPath = join(resolvedTypesOutput, `${manifestKey}.d.ts`);
+                try {
+                    // Use AST-based generator directly
+                    const generator = new AstTypeGenerator();
+                    const typeDefinitions = await generator.generateTypes({
+                        appKey: manifestKey,
+                        authenticationId,
+                        sdk,
+                    });
+                    // Write to file
+                    await writeFile(typesPath, typeDefinitions, "utf8");
+                    console.log(`🔧 Generated types for ${manifestKey} at ${typesPath}`);
+                }
+                catch (error) {
+                    console.warn(`⚠️ Failed to generate types for ${app.key}: ${error}`);
+                    // Continue even if type generation fails
+                }
+            }
+            catch (error) {
+                console.warn(`⚠️ Failed to process ${app.key}: ${error}`);
+            }
+        }
+        console.log(`✅ Added ${apps.length} app(s) to manifest`);
+    }, AddSchema);
+    return {
+        add,
+        context: {
+            meta: {
+                add: {
+                    categories: ["utility"],
+                    inputSchema: AddSchema,
+                },
+            },
+        },
+    };
+};

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

@@ -0,0 +1,18 @@
+import { z } from "zod";
+export declare const AddSchema: z.ZodObject<{
+    appKeys: z.ZodArray<z.ZodString, "many">;
+    authenticationIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    configPath: z.ZodOptional<z.ZodString>;
+    typesOutput: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    appKeys: string[];
+    authenticationIds?: string[] | undefined;
+    configPath?: string | undefined;
+    typesOutput?: string | undefined;
+}, {
+    appKeys: string[];
+    authenticationIds?: string[] | undefined;
+    configPath?: string | undefined;
+    typesOutput?: string | undefined;
+}>;
+export type AddOptions = z.infer<typeof AddSchema>;

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

@@ -0,0 +1,19 @@
+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"),
+    authenticationIds: z
+        .array(z.string())
+        .optional()
+        .describe("Authentication IDs to use for type generation"),
+    configPath: z
+        .string()
+        .optional()
+        .describe(`Path to Zapier config file (defaults to '${DEFAULT_CONFIG_PATH}')`),
+    typesOutput: z
+        .string()
+        .optional()
+        .describe("Directory for TypeScript type files (defaults to (src|lib|.)/zapier/apps/)"),
+});

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

@@ -0,0 +1,15 @@
+import type { Plugin } from "@zapier/zapier-sdk";
+import { GetLoginConfigPathSchema, type GetLoginConfigPathOptions } from "./schemas";
+export interface GetLoginConfigPathPluginProvides {
+    getLoginConfigPath: (options?: GetLoginConfigPathOptions) => Promise<string>;
+    context: {
+        meta: {
+            getLoginConfigPath: {
+                inputSchema: typeof GetLoginConfigPathSchema;
+            };
+        };
+    };
+}
+export declare const getLoginConfigPathPlugin: Plugin<{}, // requires no existing SDK methods
+{}, // requires no context
+GetLoginConfigPathPluginProvides>;

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

@@ -0,0 +1,19 @@
+import { GetLoginConfigPathSchema, } from "./schemas";
+import { createFunction } from "@zapier/zapier-sdk";
+import { getConfigPath } from "@zapier/zapier-sdk-cli-login";
+export const getLoginConfigPathPlugin = () => {
+    const getLoginConfigPathWithSdk = createFunction(async function getLoginConfigPathWithSdk(_options) {
+        return getConfigPath();
+    }, GetLoginConfigPathSchema);
+    return {
+        getLoginConfigPath: getLoginConfigPathWithSdk,
+        context: {
+            meta: {
+                getLoginConfigPath: {
+                    categories: ["utility"],
+                    inputSchema: GetLoginConfigPathSchema,
+                },
+            },
+        },
+    };
+};

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

@@ -0,0 +1,3 @@
+import { z } from "zod";
+export declare const GetLoginConfigPathSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export type GetLoginConfigPathOptions = z.infer<typeof GetLoginConfigPathSchema>;