@zapier/zapier-sdk-cli 0.42.2 → 0.43.1

package/dist/index.mjs

@@ -1,8 +1,14 @@
-import * as cliLogin from '@zapier/zapier-sdk-cli-login';
-import { logout, getConfigPath, getLoggedInUser, getPkceLoginConfig, AUTH_MODE_HEADER, getLoginStorageMode, updateLogin } from '@zapier/zapier-sdk-cli-login';
-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 open from 'open';
+import Conf from 'conf';
+import * as fs from 'fs';
+import { promises, createWriteStream, existsSync, readdirSync, rmSync, mkdirSync, writeFileSync, copyFileSync, readFileSync } from 'fs';
+import * as jwt from 'jsonwebtoken';
+import { getPassword, getKeyring, setPassword, deletePassword } from 'cross-keychain';
 import crypto, { createHash } from 'crypto';
+import * as path from 'path';
+import { resolve, join, dirname, basename, relative, extname } from 'path';
+import * as lockfile from 'proper-lockfile';
+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';
 import ora from 'ora';
@@ -11,10 +17,6 @@ import inquirer from 'inquirer';
 import { z } from 'zod';
 import { startMcpServer } from '@zapier/zapier-sdk-mcp';
 import { buildSync } from 'esbuild';
-import * as fs from 'fs';
-import { promises, createWriteStream, existsSync, readdirSync, rmSync, mkdirSync, writeFileSync, copyFileSync, readFileSync } from 'fs';
-import * as path from 'path';
-import { resolve, join, dirname, basename, relative, extname } from 'path';
 import { mkdir, writeFile, access } from 'fs/promises';
 import * as ts from 'typescript';
 import 'is-installed-globally';
@@ -22,7 +24,586 @@ import { execSync } from 'child_process';
 import Handlebars from 'handlebars';
 import { fileURLToPath } from 'url';
 
-// src/sdk.ts
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/login.ts
+var login_exports = {};
+__export(login_exports, {
+  AUTH_MODE_HEADER: () => AUTH_MODE_HEADER,
+  ZapierAuthenticationError: () => ZapierAuthenticationError,
+  createCache: () => createCache,
+  getAuthAuthorizeUrl: () => getAuthAuthorizeUrl,
+  getAuthTokenUrl: () => getAuthTokenUrl,
+  getConfig: () => getConfig,
+  getConfigPath: () => getConfigPath,
+  getLoggedInUser: () => getLoggedInUser,
+  getLoginStorageMode: () => getLoginStorageMode,
+  getPkceLoginConfig: () => getPkceLoginConfig,
+  getToken: () => getToken,
+  logout: () => logout,
+  unloadConfig: () => unloadConfig,
+  updateLogin: () => updateLogin
+});
+var SERVICE = "zapier-sdk-cli";
+var ACCOUNT = "login";
+var cachedBackendInfo;
+async function getBackendInfo() {
+  if (!cachedBackendInfo) {
+    const keyring = await getKeyring();
+    cachedBackendInfo = `${keyring.name} (${keyring.id})`;
+  }
+  return cachedBackendInfo;
+}
+var keychainQueue = Promise.resolve();
+function enqueue(fn) {
+  const result = keychainQueue.then(fn, fn);
+  keychainQueue = result.then(
+    () => {
+    },
+    () => {
+    }
+  );
+  return result;
+}
+async function getTokensFromKeychain({
+  debugLog
+} = {}) {
+  return enqueue(async () => {
+    const backendInfo = await getBackendInfo();
+    debugLog?.(`Keychain read via ${backendInfo}`);
+    const startTime = Date.now();
+    const raw = await getPassword(SERVICE, ACCOUNT);
+    debugLog?.(`Keychain read completed in ${Date.now() - startTime}ms`);
+    if (!raw) {
+      debugLog?.("Keychain returned no data");
+      return void 0;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      debugLog?.("Keychain data is not valid JSON");
+      return void 0;
+    }
+    if (typeof parsed.login_jwt === "string" && typeof parsed.login_refresh_token === "string") {
+      return {
+        login_jwt: parsed.login_jwt,
+        login_refresh_token: parsed.login_refresh_token
+      };
+    }
+    debugLog?.("Keychain data has invalid shape", parsed);
+    return void 0;
+  });
+}
+async function setTokensInKeychain({
+  data,
+  debugLog
+}) {
+  return enqueue(async () => {
+    const backendInfo = await getBackendInfo();
+    debugLog?.(`Keychain write via ${backendInfo}`);
+    const startTime = Date.now();
+    await setPassword(SERVICE, ACCOUNT, JSON.stringify(data));
+    debugLog?.(`Keychain write completed in ${Date.now() - startTime}ms`);
+  });
+}
+async function clearTokensFromKeychain({
+  debugLog
+} = {}) {
+  return enqueue(async () => {
+    try {
+      const backendInfo = await getBackendInfo();
+      debugLog?.(`Keychain clear via ${backendInfo}`);
+      await deletePassword(SERVICE, ACCOUNT);
+    } catch {
+    }
+  });
+}
+var SERVICE2 = "zapier-sdk-cache";
+var CONFIG_KEY = "cache";
+var LOCK_UPDATE_MS = 5e3;
+var LOCK_STALE_MS = 1e4;
+var LOCK_RETRY_WAIT_MS = 100;
+var LOCK_RETRY_MAX_WAIT_MS = 1e3;
+var LOCK_RETRY_COUNT = 120;
+function keychainAccount(key) {
+  return createHash("sha256").update(key).digest("hex");
+}
+function readConfigMap() {
+  const cfg = getConfig();
+  const stored = cfg.get(CONFIG_KEY);
+  if (stored && typeof stored === "object") {
+    return stored;
+  }
+  return {};
+}
+function writeConfigMap(map) {
+  getConfig().set(CONFIG_KEY, map);
+}
+function entryIsExpired(entry) {
+  return entry.expires_at !== void 0 && entry.expires_at <= Date.now();
+}
+function createCache() {
+  return {
+    async get(key) {
+      const entry = readConfigMap()[key];
+      if (!entry) return void 0;
+      if (entryIsExpired(entry)) return void 0;
+      if (entry.secret) {
+        const stored = await enqueue(async () => {
+          await getBackendInfo();
+          return getPassword(SERVICE2, keychainAccount(key));
+        });
+        if (!stored) {
+          return void 0;
+        }
+        return { value: stored, expiresAt: entry.expires_at };
+      }
+      if (entry.value === void 0) return void 0;
+      return { value: entry.value, expiresAt: entry.expires_at };
+    },
+    async set(key, value, options) {
+      const secret = options?.secret ?? false;
+      const expiresAt = options?.ttl ? Date.now() + options.ttl * 1e3 : void 0;
+      if (secret) {
+        try {
+          await enqueue(async () => {
+            await getBackendInfo();
+            await setPassword(SERVICE2, keychainAccount(key), value);
+          });
+        } catch {
+          return;
+        }
+        const map = readConfigMap();
+        map[key] = { secret: true, expires_at: expiresAt };
+        try {
+          writeConfigMap(map);
+        } catch {
+        }
+      } else {
+        const map = readConfigMap();
+        map[key] = { secret: false, value, expires_at: expiresAt };
+        try {
+          writeConfigMap(map);
+        } catch {
+        }
+      }
+    },
+    async delete(key) {
+      const map = readConfigMap();
+      const entry = map[key];
+      if (entry) {
+        delete map[key];
+        try {
+          writeConfigMap(map);
+        } catch {
+        }
+      }
+      if (entry?.secret) {
+        try {
+          await enqueue(async () => {
+            await getBackendInfo();
+            await deletePassword(SERVICE2, keychainAccount(key));
+          });
+        } catch {
+        }
+      }
+    },
+    async withLock(_key, fn) {
+      const cfg = getConfig();
+      const lockTarget = `${cfg.path}.cache-lock`;
+      try {
+        mkdirSync(dirname(lockTarget), { recursive: true });
+        if (!existsSync(lockTarget)) {
+          writeFileSync(lockTarget, "");
+        }
+      } catch {
+        return fn();
+      }
+      let release = null;
+      try {
+        release = await lockfile.lock(lockTarget, {
+          stale: LOCK_STALE_MS,
+          update: LOCK_UPDATE_MS,
+          retries: {
+            retries: LOCK_RETRY_COUNT,
+            factor: 1.2,
+            minTimeout: LOCK_RETRY_WAIT_MS,
+            maxTimeout: LOCK_RETRY_MAX_WAIT_MS
+          }
+        });
+      } catch {
+        return fn();
+      }
+      try {
+        return await fn();
+      } finally {
+        try {
+          await release();
+        } catch {
+        }
+      }
+    }
+  };
+}
+
+// src/login/index.ts
+var ZapierAuthenticationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ZapierAuthenticationError";
+  }
+};
+var config = null;
+var DEFAULT_AUTH_CLIENT_ID = "grwWZD5hUWGvb4V8ODBuOtXer3h0DBEZ2HR8aay6";
+var TOKEN_REFRESH_BUFFER_MS = 5 * 60 * 1e3;
+function createDebugLog(enabled) {
+  if (!enabled) {
+    return () => {
+    };
+  }
+  return (message, data) => {
+    if (data === void 0) {
+      console.log(`[Zapier SDK CLI Login] ${message}`);
+    } else {
+      console.log(`[Zapier SDK CLI Login] ${message}`, data);
+    }
+  };
+}
+function censorHeaderValue(value) {
+  if (value.length > 12) {
+    return `${value.substring(0, 4)}...${value.substring(value.length - 4)}`;
+  }
+  return `${value.charAt(0)}...`;
+}
+function getAuthClientId(clientId) {
+  return clientId || DEFAULT_AUTH_CLIENT_ID;
+}
+var AUTH_MODE_HEADER = "X-Auth";
+var DEFAULT_AUTH_BASE_URL = "https://zapier.com";
+function getAuthTokenUrl(options) {
+  const authBaseUrl = options?.baseUrl || DEFAULT_AUTH_BASE_URL;
+  return `${authBaseUrl}/oauth/token/`;
+}
+function getAuthAuthorizeUrl(options) {
+  const authBaseUrl = options?.baseUrl || DEFAULT_AUTH_BASE_URL;
+  return `${authBaseUrl}/oauth/authorize/`;
+}
+function getPkceLoginConfig(options) {
+  return {
+    clientId: getAuthClientId(options?.credentials?.clientId),
+    tokenUrl: getAuthTokenUrl({ baseUrl: options?.credentials?.baseUrl }),
+    authorizeUrl: getAuthAuthorizeUrl({
+      baseUrl: options?.credentials?.baseUrl
+    })
+  };
+}
+var cachedLogin;
+function getConfig() {
+  if (!config) {
+    config = new Conf({ projectName: "zapier-sdk-cli" });
+    if (!config.has("login_storage_mode")) {
+      config.set(
+        "login_storage_mode",
+        existsSync(config.path) ? "config" : "keychain"
+      );
+    }
+  }
+  return config;
+}
+function unloadConfig() {
+  config = null;
+  cachedLogin = void 0;
+}
+async function updateLogin(loginData, options = {}) {
+  const debugLog = createDebugLog(options.debug ?? false);
+  const storage = options.storage ?? cachedLogin?.storage ?? "keychain";
+  const expiresAt = Date.now() + loginData.expires_in * 1e3;
+  const cfg = getConfig();
+  cfg.set("login_storage_mode", storage);
+  if (storage === "keychain") {
+    await setTokensInKeychain({
+      data: {
+        login_jwt: loginData.access_token,
+        login_refresh_token: loginData.refresh_token
+      },
+      debugLog
+    });
+    cfg.set("login_expires_at", expiresAt);
+    cfg.delete("login_jwt");
+    cfg.delete("login_refresh_token");
+  } else {
+    cfg.set("login_jwt", loginData.access_token);
+    cfg.set("login_refresh_token", loginData.refresh_token);
+    cfg.set("login_expires_at", expiresAt);
+    await clearTokensFromKeychain({ debugLog });
+  }
+  cachedLogin = {
+    jwt: loginData.access_token,
+    refreshToken: loginData.refresh_token,
+    expiresAt,
+    storage
+  };
+}
+function decodeJwtOrThrow(token) {
+  if (typeof token !== "string") {
+    throw new Error("Expected JWT to be a string");
+  }
+  const decodedJwt = jwt.decode(token, { complete: true });
+  if (!decodedJwt) {
+    throw new Error("Could not decode JWT");
+  }
+  if (typeof decodedJwt.payload === "string") {
+    throw new Error("Did not expect JWT payload to be a string");
+  }
+  return decodedJwt;
+}
+async function refreshJwt(refreshToken, options = {}) {
+  const {
+    onEvent,
+    fetch: fetch2 = globalThis.fetch,
+    credentials,
+    debug = false
+  } = options;
+  const debugLog = createDebugLog(debug);
+  const tokenUrl = getAuthTokenUrl({ baseUrl: credentials?.baseUrl });
+  const clientId = getAuthClientId(credentials?.clientId);
+  const startTime = Date.now();
+  try {
+    onEvent?.({
+      type: "auth_refreshing",
+      payload: {
+        message: "Refreshing your token...",
+        operation: "token_refresh"
+      },
+      timestamp: Date.now()
+    });
+    debugLog(`\u2192 POST ${tokenUrl}`, {
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        [AUTH_MODE_HEADER]: "no"
+      },
+      body: {
+        client_id: clientId,
+        refresh_token: censorHeaderValue(refreshToken),
+        grant_type: "refresh_token"
+      }
+    });
+    const response = await fetch2(tokenUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        [AUTH_MODE_HEADER]: "no"
+      },
+      body: new URLSearchParams({
+        client_id: clientId,
+        refresh_token: refreshToken,
+        grant_type: "refresh_token"
+      })
+    });
+    const duration = Date.now() - startTime;
+    if (!response.ok) {
+      debugLog(`\u2190 ${response.status} ${response.statusText} (${duration}ms)`);
+      throw new Error(
+        `Token refresh failed: ${response.status} ${response.statusText}`
+      );
+    }
+    debugLog(`\u2190 ${response.status} ${response.statusText} (${duration}ms)`);
+    const data = await response.json();
+    await updateLogin(data, { debug });
+    debugLog(
+      `Token refreshed and saved to ${cachedLogin?.storage ?? "keychain"}`
+    );
+    onEvent?.({
+      type: "auth_success",
+      payload: {
+        message: "Token refreshed successfully",
+        operation: "token_refresh"
+      },
+      timestamp: Date.now()
+    });
+    return data.access_token;
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    debugLog(`\u2716 Token refresh failed (${duration}ms)`, {
+      error: error instanceof Error ? error.message : error
+    });
+    cachedLogin = void 0;
+    const errorMessage = `Token refresh failed: ${error instanceof Error ? error.message : "Unknown error"}`;
+    onEvent?.({
+      type: "auth_error",
+      payload: {
+        message: errorMessage,
+        error: errorMessage,
+        operation: "token_refresh"
+      },
+      timestamp: Date.now()
+    });
+    throw error;
+  }
+}
+var pendingRefresh = null;
+var pendingResolve = null;
+async function resolveStoredLogin(debugLog) {
+  if (cachedLogin) {
+    debugLog("Using in-memory cached credentials");
+    return cachedLogin;
+  }
+  if (pendingResolve) {
+    debugLog("Waiting for existing keychain read to complete");
+    return pendingResolve;
+  }
+  pendingResolve = resolveStoredLoginFromStorage(debugLog).finally(() => {
+    pendingResolve = null;
+  });
+  return pendingResolve;
+}
+async function resolveStoredLoginFromStorage(debugLog) {
+  let cfg;
+  try {
+    cfg = getConfig();
+  } catch (error) {
+    debugLog("Failed to load config", {
+      error: error instanceof Error ? error.message : error
+    });
+    return void 0;
+  }
+  const expiresAt = cfg.get("login_expires_at");
+  const configJwt = cfg.get("login_jwt");
+  const configRefresh = cfg.get("login_refresh_token");
+  if (configJwt && configRefresh && typeof expiresAt === "number") {
+    debugLog("Loaded credentials from config (legacy format)");
+    cachedLogin = {
+      jwt: configJwt,
+      refreshToken: configRefresh,
+      expiresAt,
+      storage: "config"
+    };
+    return cachedLogin;
+  }
+  if (typeof expiresAt !== "number") {
+    debugLog("No stored login credentials found");
+    return void 0;
+  }
+  const keychainData = await getTokensFromKeychain({ debugLog });
+  if (!keychainData) {
+    debugLog("No tokens found in keychain");
+    return void 0;
+  }
+  debugLog("Loaded credentials from keychain");
+  cachedLogin = {
+    jwt: keychainData.login_jwt,
+    refreshToken: keychainData.login_refresh_token,
+    expiresAt,
+    storage: "keychain"
+  };
+  return cachedLogin;
+}
+async function resolveOrRefreshToken(options = {}) {
+  const { debug = false } = options;
+  const debugLog = createDebugLog(debug);
+  const stored = await resolveStoredLogin(debugLog);
+  if (!stored) {
+    return void 0;
+  }
+  const { jwt: storedJwt, refreshToken, expiresAt } = stored;
+  if (expiresAt > Date.now() + TOKEN_REFRESH_BUFFER_MS) {
+    debugLog("Using cached token (still valid)");
+    return storedJwt;
+  }
+  debugLog("Token expired, refreshing...");
+  if (pendingRefresh) {
+    debugLog("Waiting for existing refresh to complete");
+    return pendingRefresh;
+  }
+  pendingRefresh = refreshJwt(refreshToken, options).finally(() => {
+    pendingRefresh = null;
+  });
+  return await pendingRefresh;
+}
+async function getToken(options = {}) {
+  try {
+    return await resolveOrRefreshToken(options);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Token refresh failed";
+    throw new ZapierAuthenticationError(
+      `${message}
+Please run 'login' to authenticate again.`
+    );
+  }
+}
+async function getLoggedInUser(options = {}) {
+  const jwt2 = await getToken(options).catch(() => void 0);
+  if (!jwt2) {
+    throw new Error(
+      "No valid authentication token available. Please login first."
+    );
+  }
+  let decodedJwt = decodeJwtOrThrow(jwt2);
+  if (decodedJwt.payload["sub_type"] == "service") {
+    decodedJwt = decodeJwtOrThrow(decodedJwt.payload["njwt"]);
+  }
+  if (typeof decodedJwt.payload["zap:acc"] !== "string") {
+    throw new Error("JWT payload does not contain accountId");
+  }
+  const accountId = parseInt(decodedJwt.payload["zap:acc"], 10);
+  if (isNaN(accountId)) {
+    throw new Error("JWT accountId is not a number");
+  }
+  if (decodedJwt.payload["sub_type"] !== "customuser" || typeof decodedJwt.payload["sub"] !== "string") {
+    throw new Error("JWT payload does not contain customUserId");
+  }
+  const customUserId = parseInt(decodedJwt.payload["sub"], 10);
+  if (isNaN(customUserId)) {
+    throw new Error("JWT customUserId is not a number");
+  }
+  const email = decodedJwt.payload["zap:uname"];
+  if (typeof email !== "string") {
+    throw new Error("JWT payload does not contain email");
+  }
+  return {
+    accountId,
+    customUserId,
+    email
+  };
+}
+function getLoginStorageMode() {
+  const cfg = getConfig();
+  if (typeof cfg.get("login_jwt") === "string") {
+    return "config";
+  }
+  const explicitMode = cfg.get("login_storage_mode");
+  if (explicitMode === "keychain" || explicitMode === "config") {
+    return explicitMode;
+  }
+  return "keychain";
+}
+async function logout(options = {}) {
+  const { onEvent } = options;
+  const mode = getLoginStorageMode();
+  cachedLogin = void 0;
+  await clearTokensFromKeychain();
+  const cfg = getConfig();
+  cfg.set("login_storage_mode", mode);
+  cfg.delete("login_expires_at");
+  cfg.delete("login_jwt");
+  cfg.delete("login_refresh_token");
+  onEvent?.({
+    type: "auth_logout",
+    payload: { message: "Logged out successfully", operation: "logout" },
+    timestamp: Date.now()
+  });
+}
+function getConfigPath() {
+  const cfg = getConfig();
+  return cfg.path;
+}
+
+// src/utils/constants.ts
 var LOGIN_PORTS = [49505, 50575, 52804, 55981, 61010, 63851];
 var LOGIN_TIMEOUT_MS = 3e5;
 var ZapierCliError = class extends ZapierError {
@@ -321,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(
@@ -410,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);
@@ -492,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')"
@@ -538,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')"
@@ -1249,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')"
@@ -1408,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."
@@ -1521,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)"),
@@ -1727,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,
@@ -1970,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"),
@@ -2405,74 +2907,68 @@ 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.42.2"};
+  version: "0.43.1"};
 
 // src/sdk.ts
-injectCliLogin(cliLogin);
+injectCliLogin(login_exports);
 function createZapierCliSdk(options = {}) {
   return createZapierSdk({
     ...options,
@@ -2483,7 +2979,7 @@ function createZapierCliSdk(options = {}) {
 
 // package.json
 var package_default2 = {
-  version: "0.42.2"};
+  version: "0.43.1"};
 
 // src/telemetry/builders.ts
 function createCliBaseEvent(context = {}) {