@zapier/zapier-sdk-cli 0.8.3 → 0.9.0

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { createFunction, OutputPropertySchema, AuthenticationIdPropertySchema, AppKeyPropertySchema, createZapierSdkWithoutRegistry, registryPlugin } from '@zapier/zapier-sdk';
+import { createFunction, OutputPropertySchema, DEFAULT_CONFIG_PATH, createZapierSdkWithoutRegistry, registryPlugin } from '@zapier/zapier-sdk';
 import open from 'open';
 import crypto from 'crypto';
 import express from 'express';
@@ -8,9 +8,12 @@ import chalk from 'chalk';
 import { getLoggedInUser, logout, updateLogin, getConfigPath } from '@zapier/zapier-sdk-cli-login';
 import { z } from 'zod';
 import { startMcpServerAsProcess } from '@zapier/zapier-sdk-mcp';
+import { buildSync } from 'esbuild';
 import * as fs from 'fs';
 import * as path from 'path';
-import { buildSync } from 'esbuild';
+import { resolve, join } from 'path';
+import * as ts from 'typescript';
+import { mkdir, writeFile, access } from 'fs/promises';
 
 // src/sdk.ts
 
@@ -78,28 +81,28 @@ var client_default = api;
 
 // src/utils/getCallablePromise.ts
 var getCallablePromise = () => {
-  let resolve2 = () => {
+  let resolve3 = () => {
   };
   let reject = () => {
   };
   const promise = new Promise((_resolve, _reject) => {
-    resolve2 = _resolve;
+    resolve3 = _resolve;
     reject = _reject;
   });
   return {
     promise,
-    resolve: resolve2,
+    resolve: resolve3,
     reject
   };
 };
 var getCallablePromise_default = getCallablePromise;
 var findAvailablePort = () => {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     let portIndex = 0;
     const tryPort = (port) => {
       const server = express().listen(port, () => {
         server.close();
-        resolve2(port);
+        resolve3(port);
       });
       server.on("error", (err) => {
         if (err.code === "EADDRINUSE") {
@@ -189,15 +192,15 @@ var login = async (timeoutMs = LOGIN_TIMEOUT_MS) => {
   } finally {
     process.off("SIGINT", cleanup);
     process.off("SIGTERM", cleanup);
-    await new Promise((resolve2) => {
+    await new Promise((resolve3) => {
       const timeout = setTimeout(() => {
         log_default.info("Server close timed out, forcing connection shutdown...");
         connections.forEach((conn) => conn.destroy());
-        resolve2();
+        resolve3();
       }, 1e3);
       server.close(() => {
         clearTimeout(timeout);
-        resolve2();
+        resolve3();
       });
     });
   }
@@ -292,323 +295,6 @@ var mcpPlugin = ({ context }) => {
     }
   };
 };
-var GenerateTypesSchema = z.object({
-  appKey: AppKeyPropertySchema.describe("App key to generate SDK code for"),
-  authenticationId: AuthenticationIdPropertySchema.optional(),
-  output: OutputPropertySchema.optional().describe(
-    "Output file path (defaults to generated/<appKey>.ts)"
-  ),
-  lockFilePath: z.string().optional().describe("Path to the .zapierrc lock file (defaults to .zapierrc)")
-}).describe("Generate TypeScript SDK code for a specific app");
-var generateTypesPlugin = ({ sdk }) => {
-  const generateTypesWithSdk = createFunction(
-    async function generateTypesWithSdk2(options) {
-      return await generateTypes({ ...options, sdk });
-    },
-    GenerateTypesSchema
-  );
-  return {
-    generateTypes: generateTypesWithSdk,
-    context: {
-      meta: {
-        generateTypes: {
-          categories: ["utility"],
-          inputSchema: GenerateTypesSchema
-        }
-      }
-    }
-  };
-};
-function generateFetchMethodSignature() {
-  return `  /** Make authenticated HTTP requests through Zapier's Relay service */
-  fetch: (options: Omit<z.infer<typeof RelayFetchSchema>, 'authenticationId'>) => Promise<Response>`;
-}
-async function generateTypes(options) {
-  const {
-    appKey,
-    authenticationId,
-    output = `./types/${appKey}.d.ts`,
-    sdk
-  } = options;
-  const { app, version } = parseAppIdentifier(appKey);
-  const actionsResult = await sdk.listActions({
-    appKey: app
-  });
-  const actions = actionsResult.data;
-  if (actions.length === 0) {
-    const typeDefinitions2 = generateEmptyTypesFile(app, version);
-    if (output) {
-      fs.mkdirSync(path.dirname(output), { recursive: true });
-      fs.writeFileSync(output, typeDefinitions2, "utf8");
-    }
-    return typeDefinitions2;
-  }
-  const actionsWithFields = [];
-  if (authenticationId) {
-    for (const action of actions) {
-      try {
-        const manifestEntry = sdk.getContext().getManifestEntry(appKey);
-        const fieldsResult = await sdk.listInputFields({
-          // If the appKey is in the manifest, use the appKey so that the types are consistent with the manifest's version, otherwise use the action.app_key
-          appKey: manifestEntry ? appKey : action.app_key,
-          actionKey: action.key,
-          actionType: action.action_type,
-          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 {
-        actionsWithFields.push({
-          ...action,
-          inputFields: [],
-          name: action.title || action.key
-        });
-      }
-    }
-  } else {
-    actions.forEach((action) => {
-      actionsWithFields.push({
-        ...action,
-        inputFields: [],
-        name: action.title || action.key
-      });
-    });
-  }
-  const typeDefinitions = generateTypeDefinitions(
-    app,
-    actionsWithFields,
-    version
-  );
-  if (output) {
-    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) {
-  if (actions.length === 0) {
-    return generateEmptyTypesFile(appKey, version);
-  }
-  const actionsByType = actions.reduce(
-    (acc, action) => {
-      if (!acc[action.action_type]) {
-        acc[action.action_type] = [];
-      }
-      acc[action.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: ${(/* @__PURE__ */ new Date()).toISOString()}
- * 
- * Usage:
- *   import type { ${appName}Sdk } from './path/to/this/file'
- *   const sdk = createZapierSdk() as unknown as ${appName}Sdk
- *   
- *   // Direct usage (per-call auth):
- *   await sdk.apps.${appKey}.search.user_by_email({ authenticationId: 123, inputs: { email } })
- *   
- *   // Factory usage (pinned auth):
- *   const my${appName} = sdk.apps.${appKey}({ authenticationId: 123 })
- *   await my${appName}.search.user_by_email({ inputs: { email } })
- */
-
-import type { ActionExecutionOptions, ActionExecutionResult } from '@zapier/zapier-sdk'
-import { z } from 'zod'
-import { RelayFetchSchema } from '@zapier/zapier-sdk'
-
-`;
-  actions.forEach((action) => {
-    if (action.inputFields.length > 0) {
-      const inputTypeName = `${appName}${capitalize(action.action_type)}${capitalize(
-        sanitizeActionName(action.key)
-      )}Inputs`;
-      output += `interface ${inputTypeName} {
-`;
-      action.inputFields.forEach((field) => {
-        const isOptional = !field.required;
-        const fieldType = mapFieldTypeToTypeScript(field);
-        const description = field.helpText ? `  /** ${escapeComment(field.helpText)} */
-` : "";
-        output += `${description}  ${sanitizeFieldName(field.key)}${isOptional ? "?" : ""}: ${fieldType}
-`;
-      });
-      output += `}
-
-`;
-    }
-  });
-  Object.entries(actionsByType).forEach(([actionType, typeActions]) => {
-    const typeName = `${appName}${capitalize(actionType)}Actions`;
-    output += `interface ${typeName} {
-`;
-    typeActions.forEach((action) => {
-      const actionName = sanitizeActionName(action.key);
-      const description = action.description ? `  /** ${escapeComment(action.description)} */
-` : "";
-      if (action.inputFields.length > 0) {
-        const inputTypeName = `${appName}${capitalize(action.action_type)}${capitalize(
-          sanitizeActionName(action.key)
-        )}Inputs`;
-        output += `${description}  ${actionName}: (options: { inputs: ${inputTypeName} } & Omit<ActionExecutionOptions, 'inputs'>) => Promise<ActionExecutionResult>
-`;
-      } else {
-        output += `${description}  ${actionName}: (options?: { inputs?: Record<string, any> } & ActionExecutionOptions) => Promise<ActionExecutionResult>
-`;
-      }
-    });
-    output += `}
-
-`;
-  });
-  output += `interface ${appName}AppProxy {
-`;
-  Object.keys(actionsByType).forEach((actionType) => {
-    const typeName = `${appName}${capitalize(actionType)}Actions`;
-    output += `  ${actionType}: ${typeName}
-`;
-  });
-  output += generateFetchMethodSignature() + "\n";
-  output += `}
-
-`;
-  output += `interface ${appName}AppFactory {
-`;
-  output += `  (options: { authenticationId: number }): ${appName}AppProxy
-`;
-  output += `}
-
-`;
-  output += `type ${appName}AppWithFactory = ${appName}AppFactory & ${appName}AppProxy
-
-`;
-  output += `export interface ${appName}Sdk {
-`;
-  output += `  apps: {
-`;
-  output += `    ${appKey}: ${appName}AppWithFactory
-`;
-  output += `  }
-`;
-  output += `}
-`;
-  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: ${(/* @__PURE__ */ new Date()).toISOString()}
- * 
- * No actions found for this app.
- */
-
-import type { ActionExecutionOptions, ActionExecutionResult } from '@zapier/zapier-sdk'
-import { z } from 'zod'
-import { RelayFetchSchema } from '@zapier/zapier-sdk'
-
-interface ${appName}AppProxy {
-  // No actions available
-${generateFetchMethodSignature()}
-}
-
-interface ${appName}AppFactory {
-  (options: { authenticationId: number }): ${appName}AppProxy
-}
-
-type ${appName}AppWithFactory = ${appName}AppFactory & ${appName}AppProxy
-
-export interface ${appName}Sdk {
-  apps: {
-    ${appKey}: ${appName}AppWithFactory
-  }
-}
-`;
-}
-function capitalize(str) {
-  return str.charAt(0).toUpperCase() + str.slice(1).replace(/[-_]/g, "");
-}
-function sanitizeActionName(actionKey) {
-  let sanitized = actionKey.replace(/[^a-zA-Z0-9_$]/g, "_");
-  if (/^[0-9]/.test(sanitized)) {
-    sanitized = "_" + sanitized;
-  }
-  return sanitized;
-}
-function sanitizeFieldName(fieldKey) {
-  let sanitized = fieldKey.replace(/[^a-zA-Z0-9_$]/g, "_");
-  if (/^[0-9]/.test(sanitized)) {
-    sanitized = "_" + sanitized;
-  }
-  return sanitized;
-}
-function escapeComment(comment) {
-  return comment.replace(/\*\//g, "*\\/").replace(/\r?\n/g, " ");
-}
-function mapFieldTypeToTypeScript(field) {
-  if (field.choices && field.choices.length > 0) {
-    const choiceValues = field.choices.filter(
-      (choice) => choice.value !== void 0 && choice.value !== null && choice.value !== ""
-    ).map(
-      (choice) => typeof choice.value === "string" ? `"${choice.value}"` : choice.value
-    );
-    if (choiceValues.length > 0) {
-      return choiceValues.join(" | ");
-    }
-  }
-  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:
-      return "string | number | boolean";
-  }
-}
 var BundleCodeSchema = z.object({
   input: z.string().min(1).describe("Input TypeScript file path to bundle"),
   output: OutputPropertySchema.optional().describe(
@@ -700,21 +386,725 @@ async function bundleCode(options) {
     );
   }
 }
-var GetConfigPathSchema = z.object({}).describe("Show the path to the configuration file");
-var getConfigPathPlugin = () => {
-  const getConfigPathWithSdk = createFunction(
-    async function getConfigPathWithSdk2(_options) {
+var GetLoginConfigPathSchema = z.object({}).describe("Show the path to the login configuration file");
+var getLoginConfigPathPlugin = () => {
+  const getLoginConfigPathWithSdk = createFunction(
+    async function getLoginConfigPathWithSdk2(_options) {
       return getConfigPath();
     },
-    GetConfigPathSchema
+    GetLoginConfigPathSchema
   );
   return {
-    getConfigPath: getConfigPathWithSdk,
+    getLoginConfigPath: getLoginConfigPathWithSdk,
+    context: {
+      meta: {
+        getLoginConfigPath: {
+          categories: ["utility"],
+          inputSchema: GetLoginConfigPathSchema
+        }
+      }
+    }
+  };
+};
+var 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/)"
+  )
+});
+var AstTypeGenerator = class {
+  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;
+    const { app, version } = this.parseAppIdentifier(appKey);
+    const actionsResult = await sdk.listActions({
+      appKey: app
+    });
+    const actions = actionsResult.data;
+    if (actions.length === 0) {
+      return this.generateEmptyTypesFile(app, version);
+    }
+    const actionsWithFields = [];
+    if (authenticationId) {
+      for (const action of actions) {
+        try {
+          const fieldsResult = await sdk.listInputFields({
+            appKey,
+            actionKey: action.key,
+            actionType: action.action_type,
+            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 {
+          actionsWithFields.push({
+            ...action,
+            inputFields: [],
+            name: action.title || action.key
+          });
+        }
+      }
+    } else {
+      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 || ""
+          });
+        }
+      );
+    }
+    const sourceFile = this.createSourceFile(app, actionsWithFields, version);
+    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}`;
+    const headerComment = `Auto-generated TypeScript types for Zapier ${appKey} actions
+${versionComment.slice(3)}
+Generated on: ${(/* @__PURE__ */ 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"
+      )
+    ];
+    const actionsByType = this.groupActionsByType(actions);
+    actions.forEach((action) => {
+      if (action.inputFields.length > 0) {
+        const inputInterface = this.createInputInterface(appName, action);
+        statements.push(inputInterface);
+      }
+    });
+    Object.entries(actionsByType).forEach(([actionType, typeActions]) => {
+      const actionInterface = this.createActionInterface(
+        appName,
+        actionType,
+        typeActions
+      );
+      statements.push(actionInterface);
+    });
+    const appProxyInterface = this.createAppProxyInterface(
+      appName,
+      actionsByType
+    );
+    statements.push(appProxyInterface);
+    const appFactoryInterface = this.createAppFactoryInterface(appName);
+    statements.push(appFactoryInterface);
+    const appWithFactoryType = this.createAppWithFactoryType(appName);
+    statements.push(appWithFactoryType);
+    const moduleAugmentation = this.createModuleAugmentation(appKey, appName);
+    statements.push(moduleAugmentation);
+    statements.push(
+      this.factory.createExportDeclaration(
+        void 0,
+        false,
+        this.factory.createNamedExports([])
+      )
+    );
+    const sourceFile = ts.createSourceFile(
+      "generated.d.ts",
+      "",
+      ts.ScriptTarget.Latest,
+      false,
+      ts.ScriptKind.TS
+    );
+    if (statements.length > 0) {
+      ts.addSyntheticLeadingComment(
+        statements[0],
+        ts.SyntaxKind.MultiLineCommentTrivia,
+        " eslint-disable @typescript-eslint/naming-convention, @typescript-eslint/no-explicit-any ",
+        true
+      );
+      ts.addSyntheticLeadingComment(
+        statements[0],
+        ts.SyntaxKind.MultiLineCommentTrivia,
+        headerComment,
+        true
+      );
+    }
+    return this.factory.updateSourceFile(sourceFile, statements);
+  }
+  createImportStatement(imports, from) {
+    if (imports.length === 1 && !from && imports[0].startsWith("@")) {
+      return this.factory.createImportDeclaration(
+        void 0,
+        void 0,
+        this.factory.createStringLiteral(imports[0]),
+        void 0
+      );
+    }
+    const fromModule = from || imports[0];
+    const importNames = from ? imports : [];
+    return this.factory.createImportDeclaration(
+      void 0,
+      importNames.length > 0 ? this.factory.createImportClause(
+        false,
+        void 0,
+        this.factory.createNamedImports(
+          importNames.map(
+            (name) => this.factory.createImportSpecifier(
+              false,
+              void 0,
+              this.factory.createIdentifier(name)
+            )
+          )
+        )
+      ) : void 0,
+      this.factory.createStringLiteral(fromModule),
+      void 0
+    );
+  }
+  createTypeImportStatement(imports, from) {
+    return this.factory.createImportDeclaration(
+      void 0,
+      this.factory.createImportClause(
+        true,
+        // typeOnly: true
+        void 0,
+        this.factory.createNamedImports(
+          imports.map(
+            (name) => this.factory.createImportSpecifier(
+              false,
+              void 0,
+              this.factory.createIdentifier(name)
+            )
+          )
+        )
+      ),
+      this.factory.createStringLiteral(from),
+      void 0
+    );
+  }
+  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(
+        void 0,
+        this.sanitizeFieldName(field.key),
+        isOptional ? this.factory.createToken(ts.SyntaxKind.QuestionToken) : void 0,
+        fieldType
+      );
+      if (field.helpText) {
+        property = ts.addSyntheticLeadingComment(
+          property,
+          ts.SyntaxKind.MultiLineCommentTrivia,
+          `* ${this.escapeComment(field.helpText)} `,
+          true
+        );
+      }
+      return property;
+    });
+    return this.factory.createInterfaceDeclaration(
+      void 0,
+      inputTypeName,
+      void 0,
+      void 0,
+      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) {
+        const inputTypeName = `${appName}${this.capitalize(action.action_type)}${this.capitalize(
+          this.sanitizeActionName(action.key)
+        )}Inputs`;
+        const inputsType = this.factory.createTypeLiteralNode([
+          this.factory.createPropertySignature(
+            void 0,
+            "inputs",
+            void 0,
+            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(
+          void 0,
+          actionName,
+          void 0,
+          void 0,
+          [
+            this.factory.createParameterDeclaration(
+              void 0,
+              void 0,
+              "options",
+              void 0,
+              optionsType
+            )
+          ],
+          this.factory.createTypeReferenceNode("Promise", [
+            this.factory.createTypeReferenceNode("ActionExecutionResult")
+          ])
+        );
+      } else {
+        const genericInputsType = this.factory.createTypeLiteralNode([
+          this.factory.createPropertySignature(
+            void 0,
+            "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(
+          void 0,
+          actionName,
+          void 0,
+          void 0,
+          [
+            this.factory.createParameterDeclaration(
+              void 0,
+              void 0,
+              "options",
+              this.factory.createToken(ts.SyntaxKind.QuestionToken),
+              intersectionType
+            )
+          ],
+          this.factory.createTypeReferenceNode("Promise", [
+            this.factory.createTypeReferenceNode("ActionExecutionResult")
+          ])
+        );
+      }
+      if (action.description) {
+        methodSignature = ts.addSyntheticLeadingComment(
+          methodSignature,
+          ts.SyntaxKind.MultiLineCommentTrivia,
+          `* ${this.escapeComment(action.description)} `,
+          true
+        );
+      }
+      return methodSignature;
+    });
+    return this.factory.createInterfaceDeclaration(
+      void 0,
+      typeName,
+      void 0,
+      void 0,
+      methods
+    );
+  }
+  createAppProxyInterface(appName, actionsByType) {
+    const properties = [
+      ...Object.keys(actionsByType).map(
+        (actionType) => this.factory.createPropertySignature(
+          void 0,
+          actionType,
+          void 0,
+          this.factory.createTypeReferenceNode(
+            `${appName}${this.capitalize(actionType)}Actions`
+          )
+        )
+      ),
+      // Always include fetch method for authenticated HTTP requests
+      this.createFetchMethodProperty()
+    ];
+    return this.factory.createInterfaceDeclaration(
+      void 0,
+      `${appName}AppProxy`,
+      void 0,
+      void 0,
+      properties
+    );
+  }
+  createFetchMethodProperty() {
+    let property = this.factory.createPropertySignature(
+      void 0,
+      "fetch",
+      void 0,
+      this.factory.createFunctionTypeNode(
+        void 0,
+        [
+          this.factory.createParameterDeclaration(
+            void 0,
+            void 0,
+            "url",
+            void 0,
+            this.factory.createUnionTypeNode([
+              this.factory.createTypeReferenceNode("string"),
+              this.factory.createTypeReferenceNode("URL")
+            ])
+          ),
+          this.factory.createParameterDeclaration(
+            void 0,
+            void 0,
+            "init",
+            this.factory.createToken(ts.SyntaxKind.QuestionToken),
+            this.factory.createTypeReferenceNode("ZapierFetchInitOptions")
+          )
+        ],
+        this.factory.createTypeReferenceNode("Promise", [
+          this.factory.createTypeReferenceNode("Response")
+        ])
+      )
+    );
+    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(
+      void 0,
+      [
+        this.factory.createParameterDeclaration(
+          void 0,
+          void 0,
+          "options",
+          void 0,
+          this.factory.createTypeLiteralNode([
+            this.factory.createPropertySignature(
+              void 0,
+              "authenticationId",
+              void 0,
+              this.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)
+            )
+          ])
+        )
+      ],
+      this.factory.createTypeReferenceNode(`${appName}AppProxy`)
+    );
+    return this.factory.createInterfaceDeclaration(
+      void 0,
+      `${appName}AppFactory`,
+      void 0,
+      void 0,
+      [callSignature]
+    );
+  }
+  createAppWithFactoryType(appName) {
+    return this.factory.createTypeAliasDeclaration(
+      void 0,
+      `${appName}AppWithFactory`,
+      void 0,
+      this.factory.createIntersectionTypeNode([
+        this.factory.createTypeReferenceNode(`${appName}AppFactory`),
+        this.factory.createTypeReferenceNode(`${appName}AppProxy`)
+      ])
+    );
+  }
+  createModuleAugmentation(appKey, appName) {
+    return this.factory.createModuleDeclaration(
+      [this.factory.createToken(ts.SyntaxKind.DeclareKeyword)],
+      this.factory.createStringLiteral("@zapier/zapier-sdk"),
+      this.factory.createModuleBlock([
+        this.factory.createInterfaceDeclaration(
+          void 0,
+          "ZapierSdkApps",
+          void 0,
+          void 0,
+          [
+            this.factory.createPropertySignature(
+              void 0,
+              appKey,
+              void 0,
+              this.factory.createTypeReferenceNode(`${appName}AppWithFactory`)
+            )
+          ]
+        )
+      ])
+    );
+  }
+  mapFieldTypeToTypeNode(field) {
+    if (field.choices && field.choices.length > 0) {
+      const choiceValues = field.choices.filter(
+        (choice) => choice.value !== void 0 && 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);
+      }
+    }
+    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:
+        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: ${(/* @__PURE__ */ 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) {
+    let sanitized = actionKey.replace(/[^a-zA-Z0-9_$]/g, "_");
+    if (/^[0-9]/.test(sanitized)) {
+      sanitized = "_" + sanitized;
+    }
+    return sanitized;
+  }
+  sanitizeFieldName(fieldKey) {
+    let sanitized = fieldKey.replace(/[^a-zA-Z0-9_$]/g, "_");
+    if (/^[0-9]/.test(sanitized)) {
+      sanitized = "_" + sanitized;
+    }
+    return sanitized;
+  }
+  escapeComment(comment) {
+    return comment.replace(/\*\//g, "*\\/").replace(/\r?\n/g, " ");
+  }
+};
+async function detectTypesOutputDirectory() {
+  const candidates = ["src", "lib"];
+  for (const candidate of candidates) {
+    try {
+      await access(candidate);
+      return join(candidate, "zapier", "apps");
+    } catch {
+    }
+  }
+  return "./zapier/apps/";
+}
+var addPlugin = ({ sdk, context }) => {
+  const add = createFunction(async function add2(options) {
+    const {
+      appKeys,
+      authenticationIds,
+      configPath,
+      typesOutput = await detectTypesOutputDirectory()
+    } = options;
+    const resolvedTypesOutput = resolve(typesOutput);
+    await mkdir(resolvedTypesOutput, { recursive: true });
+    console.log(`\u{1F4E6} 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("\u26A0\uFE0F No apps found");
+      return;
+    }
+    let authentications = [];
+    if (authenticationIds && authenticationIds.length > 0) {
+      console.log(
+        `\u{1F510} Looking up ${authenticationIds.length} authentication(s)...`
+      );
+      const authsIterator = sdk.listAuthentications({ authenticationIds }).items();
+      for await (const auth of authsIterator) {
+        authentications.push(auth);
+      }
+      console.log(`\u{1F510} Found ${authentications.length} authentication(s)`);
+    }
+    for (const app of apps) {
+      console.log(`\u{1F4E6} Adding ${app.key}...`);
+      try {
+        const currentImplementationId = app.current_implementation_id;
+        const [implementationName, version] = currentImplementationId.split("@");
+        if (!implementationName || !version) {
+          console.warn(
+            `\u26A0\uFE0F Invalid implementation ID format for '${app.key}': ${currentImplementationId}. Expected format: <implementationName>@<version>. Skipping...`
+          );
+          continue;
+        }
+        const [manifestKey] = await context.updateManifestEntry(
+          app.key,
+          {
+            implementationName,
+            version
+          },
+          configPath
+        );
+        console.log(
+          `\u{1F4DD} Locked ${app.key} to ${implementationName}@${version} using key '${manifestKey}'`
+        );
+        let authenticationId;
+        if (authentications.length > 0) {
+          const matchingAuth = authentications.find((auth) => {
+            return auth.app_key === app.key;
+          });
+          if (matchingAuth) {
+            authenticationId = matchingAuth.id;
+            console.log(
+              `\u{1F510} Using authentication ${authenticationId} (${matchingAuth.title}) for ${app.key}`
+            );
+          } else {
+            console.warn(`\u26A0\uFE0F No matching authentication found for ${app.key}`);
+          }
+        }
+        const typesPath = join(resolvedTypesOutput, `${manifestKey}.d.ts`);
+        try {
+          const generator = new AstTypeGenerator();
+          const typeDefinitions = await generator.generateTypes({
+            appKey: manifestKey,
+            authenticationId,
+            sdk
+          });
+          await writeFile(typesPath, typeDefinitions, "utf8");
+          console.log(`\u{1F527} Generated types for ${manifestKey} at ${typesPath}`);
+        } catch (error) {
+          console.warn(`\u26A0\uFE0F Failed to generate types for ${app.key}: ${error}`);
+        }
+      } catch (error) {
+        console.warn(`\u26A0\uFE0F Failed to process ${app.key}: ${error}`);
+      }
+    }
+    console.log(`\u2705 Added ${apps.length} app(s) to manifest`);
+  }, AddSchema);
+  return {
+    add,
     context: {
       meta: {
-        getConfigPath: {
+        add: {
           categories: ["utility"],
-          inputSchema: GetConfigPathSchema
+          inputSchema: AddSchema
         }
       }
     }
@@ -726,9 +1116,9 @@ function createZapierCliSdk(options = {}) {
   let sdk = createZapierSdkWithoutRegistry({
     debug: options.debug
   });
-  sdk = sdk.addPlugin(generateTypesPlugin);
   sdk = sdk.addPlugin(bundleCodePlugin);
-  sdk = sdk.addPlugin(getConfigPathPlugin);
+  sdk = sdk.addPlugin(getLoginConfigPathPlugin);
+  sdk = sdk.addPlugin(addPlugin);
   sdk = sdk.addPlugin(mcpPlugin);
   sdk = sdk.addPlugin(loginPlugin);
   sdk = sdk.addPlugin(logoutPlugin);