@zapier/zapier-sdk-cli 0.43.0 → 0.43.1

package/dist/index.mjs

@@ -1,13 +1,13 @@
 import Conf from 'conf';
 import * as fs from 'fs';
-import { existsSync, mkdirSync, writeFileSync, promises, createWriteStream, readdirSync, rmSync, copyFileSync, readFileSync } from 'fs';
+import { promises, createWriteStream, existsSync, readdirSync, rmSync, mkdirSync, writeFileSync, copyFileSync, readFileSync } from 'fs';
 import * as jwt from 'jsonwebtoken';
-import { deletePassword, setPassword, getPassword, getKeyring } from 'cross-keychain';
+import { getPassword, getKeyring, setPassword, deletePassword } from 'cross-keychain';
 import crypto, { createHash } from 'crypto';
 import * as path from 'path';
-import { dirname, resolve, join, basename, relative, extname } from 'path';
+import { resolve, join, dirname, basename, relative, extname } from 'path';
 import * as lockfile from 'proper-lockfile';
-import { createFunction, OutputPropertySchema, DEFAULT_CONFIG_PATH, injectCliLogin, createZapierSdk, getOsInfo, getPlatformVersions, getCiPlatform, isCi, ZapierValidationError, ZapierUnknownError, getReleaseId, getCurrentTimestamp, generateEventId, batch, toSnakeCase, buildApplicationLifecycleEvent, ZapierError, isCredentialsObject } from '@zapier/zapier-sdk';
+import { definePlugin, createPluginMethod, buildApplicationLifecycleEvent, OutputPropertySchema, DEFAULT_CONFIG_PATH, ZapierValidationError, ZapierUnknownError, injectCliLogin, isCredentialsObject, batch, toSnakeCase, ZapierError, createZapierSdk, getOsInfo, getPlatformVersions, getCiPlatform, isCi, getReleaseId, getCurrentTimestamp, generateEventId } from '@zapier/zapier-sdk';
 import open from 'open';
 import express from 'express';
 import pkceChallenge from 'pkce-challenge';
@@ -902,85 +902,65 @@ function toPkceCredentials(credentials) {
   }
   return void 0;
 }
-var loginPlugin = (sdk) => {
-  const loginFn = async (options) => {
-    const timeoutSeconds = options.timeout ? parseInt(options.timeout, 10) : 300;
-    if (isNaN(timeoutSeconds) || timeoutSeconds <= 0) {
-      throw new Error("Timeout must be a positive number");
-    }
-    const resolvedCredentials = await sdk.context.resolveCredentials();
-    const pkceCredentials = toPkceCredentials(resolvedCredentials);
-    await login_default({
-      timeoutMs: timeoutSeconds * 1e3,
-      credentials: pkceCredentials
-    });
-    const user = await getLoggedInUser();
-    sdk.context.eventEmission.emit(
-      "platform.sdk.ApplicationLifecycleEvent",
-      buildApplicationLifecycleEvent(
-        { lifecycle_event_type: "login_success" },
-        { customuser_id: user.customUserId, account_id: user.accountId }
-      )
-    );
-    console.log(`\u2705 Successfully logged in as ${user.email}`);
-  };
-  return {
-    login: loginFn,
-    context: {
-      meta: {
-        login: {
-          categories: ["account"],
-          inputSchema: LoginSchema,
-          supportsJsonOutput: false
-        }
+var loginPlugin = definePlugin(
+  (sdk) => createPluginMethod(sdk, {
+    name: "login",
+    categories: ["account"],
+    inputSchema: LoginSchema,
+    supportsJsonOutput: false,
+    handler: async ({ sdk: sdk2, options }) => {
+      const timeoutSeconds = options.timeout ? parseInt(options.timeout, 10) : 300;
+      if (isNaN(timeoutSeconds) || timeoutSeconds <= 0) {
+        throw new Error("Timeout must be a positive number");
       }
+      const resolvedCredentials = await sdk2.context.resolveCredentials();
+      const pkceCredentials = toPkceCredentials(resolvedCredentials);
+      await login_default({
+        timeoutMs: timeoutSeconds * 1e3,
+        credentials: pkceCredentials
+      });
+      const user = await getLoggedInUser();
+      sdk2.context.eventEmission.emit(
+        "platform.sdk.ApplicationLifecycleEvent",
+        buildApplicationLifecycleEvent(
+          { lifecycle_event_type: "login_success" },
+          { customuser_id: user.customUserId, account_id: user.accountId }
+        )
+      );
+      console.log(`\u2705 Successfully logged in as ${user.email}`);
     }
-  };
-};
+  })
+);
 var LogoutSchema = z.object({}).describe("Log out of your Zapier account");
 
 // src/plugins/logout/index.ts
-var logoutWithSdk = createFunction(async function logoutWithSdk2(_options) {
-  await logout();
-  console.log("\u2705 Successfully logged out");
-}, LogoutSchema);
-var logoutPlugin = () => ({
-  logout: logoutWithSdk,
-  context: {
-    meta: {
-      logout: {
-        categories: ["account"],
-        inputSchema: LogoutSchema,
-        supportsJsonOutput: false
-      }
-    }
-  }
-});
+var logoutPlugin = definePlugin(
+  (sdk) => createPluginMethod(sdk, {
+    name: "logout",
+    categories: ["account"],
+    inputSchema: LogoutSchema,
+    supportsJsonOutput: false,
+    handler: async () => {
+      await logout();
+      console.log("\u2705 Successfully logged out");
+    }
+  })
+);
 var McpSchema = z.object({
   port: z.string().optional().describe("Port to listen on (for future HTTP transport)")
 }).describe("Start MCP server for Zapier SDK");
 
 // src/plugins/mcp/index.ts
-var mcpPlugin = (sdk) => {
-  const mcpWithSdk = createFunction(async function mcpWithSdk2(options) {
-    const mcpOptions = {
-      ...options,
-      debug: sdk.context.options?.debug
-    };
-    return await startMcpServer(mcpOptions);
-  }, McpSchema);
-  return {
-    mcp: mcpWithSdk,
-    context: {
-      meta: {
-        mcp: {
-          categories: ["utility"],
-          inputSchema: McpSchema
-        }
-      }
-    }
-  };
-};
+var mcpPlugin = definePlugin(
+  (sdk) => createPluginMethod(sdk, {
+    name: "mcp",
+    categories: ["utility"],
+    inputSchema: McpSchema,
+    handler: async ({ sdk: sdk2, options }) => {
+      await startMcpServer({ ...options, debug: sdk2.context.options?.debug });
+    }
+  })
+);
 var BundleCodeSchema = z.object({
   input: z.string().min(1).describe("Input TypeScript file path to bundle"),
   output: OutputPropertySchema.optional().describe(
@@ -991,22 +971,14 @@ var BundleCodeSchema = z.object({
   target: z.string().optional().describe("ECMAScript target version"),
   cjs: z.boolean().optional().describe("Output CommonJS format instead of ESM")
 }).describe("Bundle TypeScript code into executable JavaScript");
-var bundleCodePlugin = () => {
-  const bundleCodeWithSdk = createFunction(async function bundleCodeWithSdk2(options) {
-    return await bundleCode(options);
-  }, BundleCodeSchema);
-  return {
-    bundleCode: bundleCodeWithSdk,
-    context: {
-      meta: {
-        bundleCode: {
-          categories: ["utility", "deprecated"],
-          inputSchema: BundleCodeSchema
-        }
-      }
-    }
-  };
-};
+var bundleCodePlugin = definePlugin(
+  (sdk) => createPluginMethod(sdk, {
+    name: "bundleCode",
+    categories: ["utility", "deprecated"],
+    inputSchema: BundleCodeSchema,
+    handler: async ({ options }) => bundleCode(options)
+  })
+);
 var ZapierBundleError = class extends Error {
   constructor(message, details, originalError) {
     super(message);
@@ -1073,25 +1045,14 @@ async function bundleCode(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();
-    },
-    GetLoginConfigPathSchema
-  );
-  return {
-    getLoginConfigPath: getLoginConfigPathWithSdk,
-    context: {
-      meta: {
-        getLoginConfigPath: {
-          categories: ["utility"],
-          inputSchema: GetLoginConfigPathSchema
-        }
-      }
-    }
-  };
-};
+var getLoginConfigPathPlugin = definePlugin(
+  (sdk) => createPluginMethod(sdk, {
+    name: "getLoginConfigPath",
+    categories: ["utility"],
+    inputSchema: GetLoginConfigPathSchema,
+    handler: async () => getConfigPath()
+  })
+);
 var AddSchema = z.object({
   apps: 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')"
@@ -1119,111 +1080,105 @@ async function detectTypesOutputDirectory() {
   }
   return "./zapier/apps/";
 }
-var addPlugin = (sdk) => {
-  const add = createFunction(async function add2(options) {
-    const {
-      apps: appKeys,
-      connections: connectionIds,
-      configPath,
-      typesOutput = await detectTypesOutputDirectory()
-    } = options;
-    const resolvedTypesOutput = resolve(typesOutput);
-    console.log(`\u{1F4E6} Adding ${appKeys.length} app(s)...`);
-    const appSlugAndKeyMap = /* @__PURE__ */ new Map();
-    const handleManifestProgress = (event) => {
-      switch (event.type) {
-        case "apps_lookup_start":
-          console.log(`\u{1F4E6} Looking up ${event.count} app(s)...`);
-          break;
-        case "app_found":
-          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("\u26A0\uFE0F No apps found");
-          }
-          break;
-        case "app_processing_start":
-          const appName = event.slug ? `${event.slug} (${event.app})` : event.app;
-          console.log(`\u{1F4E6} Adding ${appName}...`);
-          break;
-        case "manifest_updated":
-          const appDisplay = appSlugAndKeyMap.get(event.app) || event.app;
-          console.log(
-            `\u{1F4DD} Locked ${appDisplay} to ${event.app}@${event.version} using key '${event.manifestKey}'`
-          );
-          break;
-        case "app_processing_error":
-          const errorApp = appSlugAndKeyMap.get(event.app) || event.app;
-          console.warn(`\u26A0\uFE0F ${event.error} for ${errorApp}`);
-          break;
-      }
-    };
-    const handleTypesProgress = (event) => {
-      switch (event.type) {
-        case "connections_lookup_start":
-          console.log(`\u{1F510} Looking up ${event.count} connection(s)...`);
-          break;
-        case "connections_lookup_complete":
-          console.log(`\u{1F510} Found ${event.count} connection(s)`);
-          break;
-        case "connection_matched":
-          const appWithConnection = appSlugAndKeyMap.get(event.app) || event.app;
-          console.log(
-            `\u{1F510} Using connection ${event.connectionId} (${event.connectionTitle}) for ${appWithConnection}`
-          );
-          break;
-        case "connection_not_matched":
-          const appWithoutConnection = appSlugAndKeyMap.get(event.app) || event.app;
-          console.warn(
-            `\u26A0\uFE0F No matching connection found for ${appWithoutConnection}`
-          );
-          break;
-        case "file_written":
-          console.log(
-            `\u{1F527} Generated types for ${event.manifestKey} at ${event.filePath}`
-          );
-          break;
-        case "app_processing_error":
-          const errorApp = appSlugAndKeyMap.get(event.app) || event.app;
-          console.warn(`\u26A0\uFE0F ${event.error} for ${errorApp}`);
-          break;
-      }
-    };
-    const manifestResult = await sdk.buildManifest({
-      apps: appKeys,
-      skipWrite: false,
-      configPath,
-      onProgress: handleManifestProgress
-    });
-    const typesResult = await sdk.generateAppTypes({
-      apps: appKeys,
-      connections: connectionIds,
-      skipWrite: false,
-      typesOutputDirectory: resolvedTypesOutput,
-      onProgress: handleTypesProgress
-    });
-    const results = manifestResult.manifest?.apps || {};
-    const successfulApps = Object.keys(results).filter(
-      (manifestKey) => typesResult.writtenFiles?.[manifestKey]
-    );
-    if (successfulApps.length > 0) {
-      console.log(`\u2705 Added ${successfulApps.length} app(s) to manifest`);
-    }
-  }, AddSchema);
-  return {
-    add,
-    context: {
-      meta: {
-        add: {
-          categories: ["utility"],
-          inputSchema: AddSchema
+var addPlugin = definePlugin(
+  (sdk) => createPluginMethod(sdk, {
+    name: "add",
+    categories: ["utility"],
+    inputSchema: AddSchema,
+    handler: async ({ sdk: sdk2, options }) => {
+      const {
+        apps: appKeys,
+        connections: connectionIds,
+        configPath,
+        typesOutput = await detectTypesOutputDirectory()
+      } = options;
+      const resolvedTypesOutput = resolve(typesOutput);
+      console.log(`\u{1F4E6} Adding ${appKeys.length} app(s)...`);
+      const appSlugAndKeyMap = /* @__PURE__ */ new Map();
+      const handleManifestProgress = (event) => {
+        switch (event.type) {
+          case "apps_lookup_start":
+            console.log(`\u{1F4E6} Looking up ${event.count} app(s)...`);
+            break;
+          case "app_found":
+            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("\u26A0\uFE0F No apps found");
+            }
+            break;
+          case "app_processing_start":
+            const appName = event.slug ? `${event.slug} (${event.app})` : event.app;
+            console.log(`\u{1F4E6} Adding ${appName}...`);
+            break;
+          case "manifest_updated":
+            const appDisplay = appSlugAndKeyMap.get(event.app) || event.app;
+            console.log(
+              `\u{1F4DD} Locked ${appDisplay} to ${event.app}@${event.version} using key '${event.manifestKey}'`
+            );
+            break;
+          case "app_processing_error":
+            const errorApp = appSlugAndKeyMap.get(event.app) || event.app;
+            console.warn(`\u26A0\uFE0F ${event.error} for ${errorApp}`);
+            break;
+        }
+      };
+      const handleTypesProgress = (event) => {
+        switch (event.type) {
+          case "connections_lookup_start":
+            console.log(`\u{1F510} Looking up ${event.count} connection(s)...`);
+            break;
+          case "connections_lookup_complete":
+            console.log(`\u{1F510} Found ${event.count} connection(s)`);
+            break;
+          case "connection_matched":
+            const appWithConnection = appSlugAndKeyMap.get(event.app) || event.app;
+            console.log(
+              `\u{1F510} Using connection ${event.connectionId} (${event.connectionTitle}) for ${appWithConnection}`
+            );
+            break;
+          case "connection_not_matched":
+            const appWithoutConnection = appSlugAndKeyMap.get(event.app) || event.app;
+            console.warn(
+              `\u26A0\uFE0F No matching connection found for ${appWithoutConnection}`
+            );
+            break;
+          case "file_written":
+            console.log(
+              `\u{1F527} Generated types for ${event.manifestKey} at ${event.filePath}`
+            );
+            break;
+          case "app_processing_error":
+            const errorApp = appSlugAndKeyMap.get(event.app) || event.app;
+            console.warn(`\u26A0\uFE0F ${event.error} for ${errorApp}`);
+            break;
         }
+      };
+      const manifestResult = await sdk2.buildManifest({
+        apps: appKeys,
+        skipWrite: false,
+        configPath,
+        onProgress: handleManifestProgress
+      });
+      const typesResult = await sdk2.generateAppTypes({
+        apps: appKeys,
+        connections: connectionIds,
+        skipWrite: false,
+        typesOutputDirectory: resolvedTypesOutput,
+        onProgress: handleTypesProgress
+      });
+      const results = manifestResult.manifest?.apps || {};
+      const successfulApps = Object.keys(results).filter(
+        (manifestKey) => typesResult.writtenFiles?.[manifestKey]
+      );
+      if (successfulApps.length > 0) {
+        console.log(`\u2705 Added ${successfulApps.length} app(s) to manifest`);
       }
     }
-  };
-};
+  })
+);
 var GenerateAppTypesSchema = z.object({
   apps: 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 generate types for (e.g., 'slack', 'github', 'trello')"
@@ -1830,150 +1785,133 @@ function createManifestEntry(app) {
     version: app.version
   };
 }
-var generateAppTypesPlugin = (sdk) => {
-  const generateAppTypes = createFunction(async function generateAppTypes2(options) {
-    const {
-      apps: appKeys,
-      connections: connectionIds,
-      skipWrite = false,
-      typesOutputDirectory = await detectTypesOutputDirectory(),
-      onProgress
-    } = options;
-    const resolvedTypesOutput = resolve(typesOutputDirectory);
-    const result = {
-      typeDefinitions: {}
-    };
-    onProgress?.({ type: "apps_lookup_start", count: appKeys.length });
-    const appsIterable = sdk.listApps({ apps: appKeys }).items();
-    const apps = [];
-    for await (const app of appsIterable) {
-      apps.push(app);
-      onProgress?.({ type: "app_found", app });
-    }
-    onProgress?.({ type: "apps_lookup_complete", count: apps.length });
-    if (apps.length === 0) {
-      return result;
-    }
-    const connections = [];
-    if (connectionIds && connectionIds.length > 0) {
-      onProgress?.({
-        type: "connections_lookup_start",
-        count: connectionIds.length
-      });
-      const connectionsIterable = sdk.listConnections({ connections: connectionIds }).items();
-      for await (const connection of connectionsIterable) {
-        connections.push(connection);
+var generateAppTypesPlugin = definePlugin(
+  (sdk) => createPluginMethod(sdk, {
+    name: "generateAppTypes",
+    categories: ["utility"],
+    // Cast: schema validates JSON fields only; GenerateAppTypesOptions adds
+    // the runtime-only `onProgress` callback (passthrough via createFunction).
+    inputSchema: GenerateAppTypesSchema,
+    handler: async ({ sdk: sdk2, options }) => {
+      const {
+        apps: appKeys,
+        connections: connectionIds,
+        skipWrite = false,
+        typesOutputDirectory = await detectTypesOutputDirectory(),
+        onProgress
+      } = options;
+      const resolvedTypesOutput = resolve(typesOutputDirectory);
+      const result = { typeDefinitions: {} };
+      onProgress?.({ type: "apps_lookup_start", count: appKeys.length });
+      const appsIterable = sdk2.listApps({ apps: appKeys }).items();
+      const apps = [];
+      for await (const app of appsIterable) {
+        apps.push(app);
+        onProgress?.({ type: "app_found", app });
       }
-      onProgress?.({
-        type: "connections_lookup_complete",
-        count: connections.length
-      });
-    }
-    if (!skipWrite && resolvedTypesOutput) {
-      await mkdir(resolvedTypesOutput, { recursive: true });
-    }
-    if (!skipWrite) {
-      result.writtenFiles = {};
-    }
-    for (const app of apps) {
-      onProgress?.({
-        type: "app_processing_start",
-        app: app.key,
-        slug: app.slug
-      });
-      try {
-        if (!app.version) {
-          const errorMessage = `Invalid implementation ID format: ${app.implementation_id}. Expected format: <implementationName>@<version>`;
-          onProgress?.({
-            type: "app_processing_error",
-            app: app.key,
-            error: errorMessage
-          });
-          throw new ZapierValidationError(errorMessage, {
-            details: {
-              appKey: app.key,
-              implementationId: app.implementation_id
-            }
-          });
+      onProgress?.({ type: "apps_lookup_complete", count: apps.length });
+      if (apps.length === 0) {
+        return result;
+      }
+      const connections = [];
+      if (connectionIds && connectionIds.length > 0) {
+        onProgress?.({
+          type: "connections_lookup_start",
+          count: connectionIds.length
+        });
+        const connectionsIterable = sdk2.listConnections({ connections: connectionIds }).items();
+        for await (const connection of connectionsIterable) {
+          connections.push(connection);
         }
-        let connectionId;
-        if (connections.length > 0) {
-          const matchingConnection = connections.find((conn) => {
-            return conn.app_key === app.key;
-          });
-          if (matchingConnection) {
-            connectionId = matchingConnection.id;
+        onProgress?.({
+          type: "connections_lookup_complete",
+          count: connections.length
+        });
+      }
+      if (!skipWrite && resolvedTypesOutput) {
+        await mkdir(resolvedTypesOutput, { recursive: true });
+      }
+      if (!skipWrite) {
+        result.writtenFiles = {};
+      }
+      for (const app of apps) {
+        onProgress?.({
+          type: "app_processing_start",
+          app: app.key,
+          slug: app.slug
+        });
+        try {
+          if (!app.version) {
+            const errorMessage = `Invalid implementation ID format: ${app.implementation_id}. Expected format: <implementationName>@<version>`;
             onProgress?.({
-              type: "connection_matched",
+              type: "app_processing_error",
               app: app.key,
-              connectionId: matchingConnection.id,
-              connectionTitle: matchingConnection.title || ""
+              error: errorMessage
             });
-          } else {
-            onProgress?.({
-              type: "connection_not_matched",
-              app: app.key
+            throw new ZapierValidationError(errorMessage, {
+              details: {
+                appKey: app.key,
+                implementationId: app.implementation_id
+              }
             });
           }
-        }
-        const manifestKey = getManifestKey(app);
-        const generator = new AstTypeGenerator();
-        const typeDefinitionString = await generator.generateTypes({
-          app,
-          connectionId,
-          sdk
-        });
-        result.typeDefinitions[manifestKey] = typeDefinitionString;
-        onProgress?.({
-          type: "type_generated",
-          manifestKey,
-          sizeBytes: typeDefinitionString.length
-        });
-        if (!skipWrite && resolvedTypesOutput && result.writtenFiles) {
-          const filePath = join(resolvedTypesOutput, `${manifestKey}.d.ts`);
-          await writeFile(filePath, typeDefinitionString, "utf8");
-          result.writtenFiles[manifestKey] = filePath;
+          let connectionId;
+          if (connections.length > 0) {
+            const matchingConnection = connections.find(
+              (conn) => conn.app_key === app.key
+            );
+            if (matchingConnection) {
+              connectionId = matchingConnection.id;
+              onProgress?.({
+                type: "connection_matched",
+                app: app.key,
+                connectionId: matchingConnection.id,
+                connectionTitle: matchingConnection.title || ""
+              });
+            } else {
+              onProgress?.({
+                type: "connection_not_matched",
+                app: app.key
+              });
+            }
+          }
+          const manifestKey = getManifestKey(app);
+          const generator = new AstTypeGenerator();
+          const typeDefinitionString = await generator.generateTypes({
+            app,
+            connectionId,
+            sdk: sdk2
+          });
+          result.typeDefinitions[manifestKey] = typeDefinitionString;
           onProgress?.({
-            type: "file_written",
+            type: "type_generated",
             manifestKey,
-            filePath
+            sizeBytes: typeDefinitionString.length
           });
-        }
-        onProgress?.({
-          type: "app_processing_complete",
-          app: app.key
-        });
-      } catch (error) {
-        const errorMessage = `Failed to process app ${app.key}: ${error instanceof Error ? error.message : String(error)}`;
-        onProgress?.({
-          type: "app_processing_error",
-          app: app.key,
-          error: errorMessage
-        });
-        if (error instanceof ZapierValidationError) {
-          throw error;
-        } else {
-          throw new ZapierUnknownError(errorMessage, {
-            cause: error
-            // Works for both Error and non-Error
+          if (!skipWrite && resolvedTypesOutput && result.writtenFiles) {
+            const filePath = join(resolvedTypesOutput, `${manifestKey}.d.ts`);
+            await writeFile(filePath, typeDefinitionString, "utf8");
+            result.writtenFiles[manifestKey] = filePath;
+            onProgress?.({ type: "file_written", manifestKey, filePath });
+          }
+          onProgress?.({ type: "app_processing_complete", app: app.key });
+        } catch (error) {
+          const errorMessage = `Failed to process app ${app.key}: ${error instanceof Error ? error.message : String(error)}`;
+          onProgress?.({
+            type: "app_processing_error",
+            app: app.key,
+            error: errorMessage
           });
+          if (error instanceof ZapierValidationError) {
+            throw error;
+          }
+          throw new ZapierUnknownError(errorMessage, { cause: error });
         }
       }
+      return result;
     }
-    return result;
-  }, GenerateAppTypesSchema);
-  return {
-    generateAppTypes,
-    context: {
-      meta: {
-        generateAppTypes: {
-          categories: ["utility"],
-          inputSchema: GenerateAppTypesSchema
-        }
-      }
-    }
-  };
-};
+  })
+);
 var BuildManifestSchema = z.object({
   apps: 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 build manifest entries for (e.g., 'slack', 'github', 'trello')"
@@ -1989,86 +1927,80 @@ var BuildManifestSchema = z.object({
 );
 
 // src/plugins/buildManifest/index.ts
-var buildManifestPlugin = (sdk) => {
-  const buildManifest = createFunction(async function buildManifest2(options) {
-    const {
-      apps: appKeys,
-      skipWrite = false,
-      configPath,
-      onProgress
-    } = options;
-    onProgress?.({ type: "apps_lookup_start", count: appKeys.length });
-    const appsIterable = sdk.listApps({ apps: appKeys }).items();
-    const apps = [];
-    for await (const app of appsIterable) {
-      apps.push(app);
-      onProgress?.({ type: "app_found", app });
-    }
-    onProgress?.({ type: "apps_lookup_complete", count: apps.length });
-    if (apps.length === 0) {
-      return {};
-    }
-    let updatedManifest;
-    for (const app of apps) {
-      onProgress?.({
-        type: "app_processing_start",
-        app: app.key,
-        slug: app.slug
-      });
-      try {
-        const manifestEntry = createManifestEntry(app);
-        onProgress?.({
-          type: "manifest_entry_built",
-          app: app.key,
-          manifestKey: manifestEntry.implementationName,
-          version: manifestEntry.version || ""
-        });
-        const { key: updatedManifestKey, manifest } = await sdk.context.updateManifestEntry({
-          appKey: app.key,
-          entry: manifestEntry,
-          configPath,
-          skipWrite,
-          manifest: updatedManifest
-        });
-        updatedManifest = manifest;
-        onProgress?.({
-          type: "manifest_updated",
-          app: app.key,
-          manifestKey: updatedManifestKey,
-          version: manifestEntry.version || ""
-        });
-        onProgress?.({ type: "app_processing_complete", app: app.key });
-      } catch (error) {
-        const errorMessage = `Failed to process app ${app.key}: ${error instanceof Error ? error.message : String(error)}`;
+var buildManifestPlugin = definePlugin(
+  (sdk) => createPluginMethod(sdk, {
+    name: "buildManifest",
+    categories: ["utility"],
+    // Cast: BuildManifestSchema validates JSON-serializable fields only.
+    // BuildManifestOptions adds an `onProgress` callback that rides through
+    // `createFunction`'s passthrough spread at runtime; this widens TInput
+    // so the handler can read it.
+    inputSchema: BuildManifestSchema,
+    handler: async ({ sdk: sdk2, options }) => {
+      const {
+        apps: appKeys,
+        skipWrite = false,
+        configPath,
+        onProgress
+      } = options;
+      onProgress?.({ type: "apps_lookup_start", count: appKeys.length });
+      const appsIterable = sdk2.listApps({ apps: appKeys }).items();
+      const apps = [];
+      for await (const app of appsIterable) {
+        apps.push(app);
+        onProgress?.({ type: "app_found", app });
+      }
+      onProgress?.({ type: "apps_lookup_complete", count: apps.length });
+      if (apps.length === 0) {
+        return {};
+      }
+      let updatedManifest;
+      for (const app of apps) {
         onProgress?.({
-          type: "app_processing_error",
+          type: "app_processing_start",
           app: app.key,
-          error: errorMessage
+          slug: app.slug
         });
-        if (error instanceof ZapierValidationError) {
-          throw error;
-        } else {
-          throw new ZapierUnknownError(errorMessage, {
-            cause: error
-            // Works for both Error and non-Error
+        try {
+          const manifestEntry = createManifestEntry(app);
+          onProgress?.({
+            type: "manifest_entry_built",
+            app: app.key,
+            manifestKey: manifestEntry.implementationName,
+            version: manifestEntry.version || ""
           });
+          const { key: updatedManifestKey, manifest } = await sdk2.context.updateManifestEntry({
+            appKey: app.key,
+            entry: manifestEntry,
+            configPath,
+            skipWrite,
+            manifest: updatedManifest
+          });
+          updatedManifest = manifest;
+          onProgress?.({
+            type: "manifest_updated",
+            app: app.key,
+            manifestKey: updatedManifestKey,
+            version: manifestEntry.version || ""
+          });
+          onProgress?.({ type: "app_processing_complete", app: app.key });
+        } catch (error) {
+          const errorMessage = `Failed to process app ${app.key}: ${error instanceof Error ? error.message : String(error)}`;
+          onProgress?.({
+            type: "app_processing_error",
+            app: app.key,
+            error: errorMessage
+          });
+          if (error instanceof ZapierValidationError) {
+            throw error;
+          }
+          throw new ZapierUnknownError(errorMessage, { cause: error });
         }
       }
+      return { manifest: updatedManifest };
     }
-    return { manifest: updatedManifest };
-  }, BuildManifestSchema);
-  return {
-    buildManifest,
-    context: {
-      meta: {
-        buildManifest: {
-          categories: ["utility"],
-          inputSchema: BuildManifestSchema
-        }
-      }
-    }
-  };
-};
+  })
+);
 var FeedbackSchema = z.object({
   feedback: z.string().describe(
     "Your feedback on the Zapier SDK. Describe what worked well, what was frustrating, or any suggestions."
@@ -2102,37 +2034,31 @@ async function postWithRetry({
   }
   return response;
 }
-var feedbackPlugin = (sdk) => {
-  const debug = sdk.context.options?.debug;
-  const feedbackWithSdk = createFunction(async function feedback(options) {
-    const user = await getLoggedInUser();
-    const body = JSON.stringify({
-      email: user.email,
-      customuser_id: user.customUserId,
-      feedback: options.feedback
-    });
-    const response = await postWithRetry({ body, attemptsLeft: MAX_RETRIES });
-    if (debug) {
-      const text = await response.text();
-      console.error("[debug] Webhook response:", text);
-    }
-    return "Thank you for your feedback!";
-  }, FeedbackSchema);
-  return {
-    feedback: feedbackWithSdk,
-    context: {
-      meta: {
-        feedback: {
-          categories: ["utility"],
-          inputSchema: FeedbackSchema,
-          resolvers: {
-            feedback: feedbackResolver
-          }
-        }
+var feedbackPlugin = definePlugin(
+  (sdk) => createPluginMethod(sdk, {
+    name: "feedback",
+    categories: ["utility"],
+    inputSchema: FeedbackSchema,
+    resolvers: { feedback: feedbackResolver },
+    handler: async ({ sdk: sdk2, options }) => {
+      const user = await getLoggedInUser();
+      const body = JSON.stringify({
+        email: user.email,
+        customuser_id: user.customUserId,
+        feedback: options.feedback
+      });
+      const response = await postWithRetry({
+        body,
+        attemptsLeft: MAX_RETRIES
+      });
+      if (sdk2.context.options?.debug) {
+        const text = await response.text();
+        console.error("[debug] Webhook response:", text);
       }
+      return "Thank you for your feedback!";
     }
-  };
-};
+  })
+);
 var CurlSchema = z.object({
   url: z.string().describe("Request URL"),
   request: z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]).optional().describe("HTTP method (defaults to GET, or POST if data is provided)"),
@@ -2308,7 +2234,7 @@ async function buildFormData(formArgs, formStringArgs) {
 }
 
 // src/plugins/curl/index.ts
-var curlPlugin = (sdk) => {
+var curlPlugin = definePlugin((sdk) => {
   async function curl(options) {
     const {
       url: rawUrl,
@@ -2551,30 +2477,25 @@ ${Array.from(
       }
     }
   };
-};
-
-// src/plugins/cliOverrides/index.ts
-var cliOverridesPlugin = (sdk) => {
-  if (!sdk.context.meta.fetch) {
-    return { context: { meta: {} } };
-  }
-  return {
-    context: {
-      meta: {
-        fetch: {
-          ...sdk.context.meta.fetch,
-          categories: [
-            ...sdk.context.meta.fetch.categories || [],
-            "deprecated"
-          ],
-          deprecation: {
-            message: "This command is deprecated and will be removed soon. Use `curl` instead. Learn more: https://docs.zapier.com/sdk/cli-reference#curl"
-          }
+});
+var cliOverridesPlugin = definePlugin(
+  (sdk) => {
+    const meta = {};
+    if (sdk.context.meta.fetch) {
+      meta.fetch = {
+        ...sdk.context.meta.fetch,
+        categories: [
+          ...sdk.context.meta.fetch.categories || [],
+          "deprecated"
+        ],
+        deprecation: {
+          message: "This command is deprecated and will be removed soon. Use `curl` instead. Learn more: https://docs.zapier.com/sdk/cli-reference#curl"
         }
-      }
+      };
     }
-  };
-};
+    return { context: { meta } };
+  }
+);
 var TEMPLATES = ["basic"];
 var InitSchema = z.object({
   projectName: z.string().min(1).describe("Name of the project directory to create"),
@@ -2986,71 +2907,65 @@ function displaySummaryAndNextSteps({
 }
 
 // src/plugins/init/index.ts
-var initPlugin = () => {
-  const init = createFunction(async function init2(options) {
-    const { projectName: rawName, skipPrompts = false } = options;
-    const cwd = process.cwd();
-    const { projectName, projectDir } = validateInitOptions({ rawName, cwd });
-    const displayHooks = createConsoleDisplayHooks();
-    const packageManagerInfo = detectPackageManager(cwd);
-    if (packageManagerInfo.name === "unknown") {
-      displayHooks.onWarn(
-        "Could not detect package manager, defaulting to npm."
-      );
-    }
-    const packageManager = packageManagerInfo.name === "unknown" ? "npm" : packageManagerInfo.name;
-    const steps = getInitSteps({
-      projectDir,
-      projectName,
-      packageManager,
-      displayHooks
-    });
-    const completedSetupStepIds = [];
-    for (let i = 0; i < steps.length; i++) {
-      const step = steps[i];
-      const succeeded = await withInterruptCleanup(
-        step.cleanup,
-        () => runStep({
-          step,
-          stepNumber: i + 1,
-          totalSteps: steps.length,
-          skipPrompts,
-          displayHooks
-        })
-      );
-      if (!succeeded) break;
-      completedSetupStepIds.push(step.id);
-    }
-    if (completedSetupStepIds.length === 0) {
-      throw new ZapierCliExitError(
-        "Project setup failed \u2014 no steps completed."
-      );
-    }
-    displaySummaryAndNextSteps({
-      projectName,
-      steps,
-      completedSetupStepIds,
-      packageManager
-    });
-  }, InitSchema);
-  return {
-    init,
-    context: {
-      meta: {
-        init: {
-          categories: ["utility"],
-          inputSchema: InitSchema,
-          supportsJsonOutput: false
-        }
+var initPlugin = definePlugin(
+  (sdk) => createPluginMethod(sdk, {
+    name: "init",
+    categories: ["utility"],
+    inputSchema: InitSchema,
+    supportsJsonOutput: false,
+    handler: async ({ options }) => {
+      const { projectName: rawName, skipPrompts = false } = options;
+      const cwd = process.cwd();
+      const { projectName, projectDir } = validateInitOptions({ rawName, cwd });
+      const displayHooks = createConsoleDisplayHooks();
+      const packageManagerInfo = detectPackageManager(cwd);
+      if (packageManagerInfo.name === "unknown") {
+        displayHooks.onWarn(
+          "Could not detect package manager, defaulting to npm."
+        );
+      }
+      const packageManager = packageManagerInfo.name === "unknown" ? "npm" : packageManagerInfo.name;
+      const steps = getInitSteps({
+        projectDir,
+        projectName,
+        packageManager,
+        displayHooks
+      });
+      const completedSetupStepIds = [];
+      for (let i = 0; i < steps.length; i++) {
+        const step = steps[i];
+        const succeeded = await withInterruptCleanup(
+          step.cleanup,
+          () => runStep({
+            step,
+            stepNumber: i + 1,
+            totalSteps: steps.length,
+            skipPrompts,
+            displayHooks
+          })
+        );
+        if (!succeeded) break;
+        completedSetupStepIds.push(step.id);
       }
+      if (completedSetupStepIds.length === 0) {
+        throw new ZapierCliExitError(
+          "Project setup failed \u2014 no steps completed."
+        );
+      }
+      displaySummaryAndNextSteps({
+        projectName,
+        steps,
+        completedSetupStepIds,
+        packageManager
+      });
     }
-  };
-};
+  })
+);
 
 // package.json with { type: 'json' }
 var package_default = {
   name: "@zapier/zapier-sdk-cli",
-  version: "0.43.0"};
+  version: "0.43.1"};
 
 // src/sdk.ts
 injectCliLogin(login_exports);
@@ -3064,7 +2979,7 @@ function createZapierCliSdk(options = {}) {
 
 // package.json
 var package_default2 = {
-  version: "0.43.0"};
+  version: "0.43.1"};
 
 // src/telemetry/builders.ts
 function createCliBaseEvent(context = {}) {