@zapier/zapier-sdk-cli 0.43.4 → 0.44.0

package/dist/package.json

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

package/dist/src/cli.js

@@ -2,6 +2,7 @@
 import { Command, CommanderError } from "commander";
 import { generateCliCommands } from "./utils/cli-generator";
 import { createZapierCliSdk } from "./sdk";
+import { resolveExtensions } from "./utils/extensions";
 import packageJson from "../package.json" with { type: "json" };
 import { ZapierCliError } from "./utils/errors";
 import { checkAndNotifyUpdates } from "./utils/version-checker";
@@ -102,24 +103,27 @@ for (const { camelName, kebabFlag } of booleanFlags) {
         flagOverrides[camelName] = true;
     }
 }
-// Create CLI SDK instance with all plugins and URL options
-const sdk = createZapierCliSdk({
-    debug: isDebugMode,
-    credentials,
-    baseUrl,
-    trackingBaseUrl,
-    maxNetworkRetries,
-    maxNetworkRetryDelayMs,
-    ...flagOverrides,
-});
-// Auth commands now handled by plugins
-// Generate CLI commands from SDK schemas (including CLI plugins)
-generateCliCommands(program, sdk);
-// MCP command now handled by plugin
 // Override Commander's default exit behavior to handle our custom errors
 program.exitOverride();
 (async () => {
     let exitCode = 0;
+    // Resolve extension packages declared via the ZAPIER_SDK_EXTENSIONS env
+    // var. Pre-resolving here keeps createZapierCliSdk synchronous for
+    // programmatic callers.
+    const extensions = await resolveExtensions();
+    // Create CLI SDK instance with all plugins and URL options
+    const sdk = createZapierCliSdk({
+        debug: isDebugMode,
+        credentials,
+        baseUrl,
+        trackingBaseUrl,
+        maxNetworkRetries,
+        maxNetworkRetryDelayMs,
+        ...flagOverrides,
+        extensions,
+    });
+    // Generate CLI commands from SDK schemas (including CLI plugins and extensions)
+    generateCliCommands(program, sdk);
     // Start version checking non-blocking
     const versionCheckPromise = checkAndNotifyUpdates({
         packageName: packageJson.name,

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

@@ -1,8 +1,10 @@
+import { type Plugin, type PluginProvides } from "@zapier/zapier-sdk";
 export declare const mcpPlugin: (sdk: {
     context: {
         options?: {
             debug?: boolean;
         };
+        extensions?: Plugin<unknown, PluginProvides>[];
     };
 } & {
     context: import("@zapier/zapier-sdk").EventEmissionContext;

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

@@ -6,7 +6,14 @@ export const mcpPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
     categories: ["utility"],
     inputSchema: McpSchema,
     handler: async ({ sdk, options }) => {
-        // Pass through the SDK's debug option to the MCP server
-        await startMcpServer({ ...options, debug: sdk.context.options?.debug });
+        // Forward debug + the extensions resolved at CLI startup so the MCP
+        // server's registry includes extension functions as tools. Without
+        // this forward, MCP would build a vanilla SDK and the CLI/MCP
+        // surfaces would diverge.
+        await startMcpServer({
+            ...options,
+            debug: sdk.context.options?.debug,
+            extensions: sdk.context.extensions,
+        });
     },
 }));

package/dist/src/sdk.d.ts

@@ -1,6 +1,14 @@
-import { type ZapierSdkOptions } from "@zapier/zapier-sdk";
+import { type Plugin, type PluginProvides, type ZapierSdkOptions } from "@zapier/zapier-sdk";
 import type { ZapierSdkCli } from "./types/sdk";
 export interface ZapierCliSdkOptions extends ZapierSdkOptions {
+    /**
+     * Extra plugins discovered from `@zapier/zapier-sdk` extension packages.
+     * Pre-resolved by `cli.ts` (`utils/extensions.ts`) so this factory stays
+     * synchronous. Each plugin is layered onto the chain after all built-in
+     * CLI plugins, so its functions appear in `getRegistry({ package: "cli" })`
+     * automatically.
+     */
+    extensions?: Plugin<unknown, PluginProvides>[];
 }
 /**
  * Create a Zapier SDK instance configured specifically for the CLI

package/dist/src/sdk.js

@@ -8,11 +8,19 @@ injectCliLogin(cliLogin);
  * Includes all CLI-specific plugins in addition to the standard SDK functionality
  */
 export function createZapierCliSdk(options = {}) {
-    return createZapierSdk({
-        ...options,
-        eventEmission: { ...options.eventEmission, callContext: "cli" },
+    const { extensions = [], ...sdkOptions } = options;
+    // Stash the resolved extensions on context so `mcpPlugin` can forward
+    // them to `startMcpServer`. Without this, MCP would build a vanilla SDK
+    // with no extensions and the CLI/MCP surfaces would diverge.
+    const extensionsContextPlugin = () => ({
+        context: { extensions },
+    });
+    let chain = createZapierSdk({
+        ...sdkOptions,
+        eventEmission: { ...sdkOptions.eventEmission, callContext: "cli" },
         callerPackage: { name: packageJson.name, version: packageJson.version },
     })
+        .addPlugin(extensionsContextPlugin)
         .addPlugin(generateAppTypesPlugin)
         .addPlugin(buildManifestPlugin)
         .addPlugin(bundleCodePlugin)
@@ -25,4 +33,19 @@ export function createZapierCliSdk(options = {}) {
         .addPlugin(loginPlugin)
         .addPlugin(logoutPlugin)
         .addPlugin(cliOverridesPlugin);
+    // Construct extensions defensively. The loader (`utils/extensions.ts`)
+    // already isolates *load*-time failures (failed dynamic imports);
+    // here we cover the second failure mode — a successfully-imported
+    // plugin that throws during construction (bad context lookup, schema
+    // build error, composePlugins collision, etc.). Honors the
+    // design-doc promise that "a broken extension does not kill the CLI."
+    for (const ext of extensions) {
+        try {
+            chain = chain.addPlugin(ext);
+        }
+        catch (err) {
+            console.warn(`Extension plugin failed to construct: ${err.message}; skipping.`);
+        }
+    }
+    return chain;
 }

package/dist/src/utils/extensions.d.ts

@@ -0,0 +1,20 @@
+import type { Plugin, PluginProvides } from "@zapier/zapier-sdk";
+/**
+ * Discovers and dynamically imports SDK extension packages declared via the
+ * `ZAPIER_SDK_EXTENSIONS` env var (comma-separated package specifiers).
+ * Each spec is `await import()`-ed and its default export is normalized via
+ * {@link normalizeExtension}. A failed import or unrecognized export shape
+ * triggers a warning and skip — a broken extension never kills the CLI.
+ *
+ * A richer, declarative discovery path (e.g. `.zapierrc` extensions) is
+ * tracked as a follow-up; for now the env var is the only entry point.
+ */
+export declare function resolveExtensions(): Promise<Plugin<unknown, PluginProvides>[]>;
+/**
+ * Translates a module's default export into a plugin array suitable for
+ * `.addPlugin(...)`. Accepts:
+ *   - a single Plugin function → `[fn]`
+ *   - an array of Plugin functions → returned as-is
+ * Returns `null` for unrecognized shapes (caller emits a skip warning).
+ */
+export declare function normalizeExtension(exported: unknown): Plugin<unknown, PluginProvides>[] | null;

package/dist/src/utils/extensions.js

@@ -0,0 +1,66 @@
+const ENV_VAR = "ZAPIER_SDK_EXTENSIONS";
+/**
+ * Discovers and dynamically imports SDK extension packages declared via the
+ * `ZAPIER_SDK_EXTENSIONS` env var (comma-separated package specifiers).
+ * Each spec is `await import()`-ed and its default export is normalized via
+ * {@link normalizeExtension}. A failed import or unrecognized export shape
+ * triggers a warning and skip — a broken extension never kills the CLI.
+ *
+ * A richer, declarative discovery path (e.g. `.zapierrc` extensions) is
+ * tracked as a follow-up; for now the env var is the only entry point.
+ */
+export async function resolveExtensions() {
+    const seen = new Set();
+    const specs = readEnvSpecs().filter((spec) => {
+        if (seen.has(spec))
+            return false;
+        seen.add(spec);
+        return true;
+    });
+    const plugins = [];
+    for (const spec of specs) {
+        try {
+            const mod = await import(spec);
+            const exported = mod.default ?? mod;
+            const got = normalizeExtension(exported);
+            if (got) {
+                plugins.push(...got);
+            }
+            else {
+                console.warn(`Extension '${spec}': unrecognized default export shape; skipping.`);
+            }
+        }
+        catch (err) {
+            console.warn(`Extension '${spec}' failed to load: ${err.message}`);
+        }
+    }
+    return plugins;
+}
+/**
+ * Translates a module's default export into a plugin array suitable for
+ * `.addPlugin(...)`. Accepts:
+ *   - a single Plugin function → `[fn]`
+ *   - an array of Plugin functions → returned as-is
+ * Returns `null` for unrecognized shapes (caller emits a skip warning).
+ */
+export function normalizeExtension(exported) {
+    if (typeof exported === "function") {
+        return [exported];
+    }
+    if (Array.isArray(exported)) {
+        if (exported.every((e) => typeof e === "function")) {
+            return exported;
+        }
+        return null;
+    }
+    return null;
+}
+function readEnvSpecs() {
+    const raw = process.env[ENV_VAR];
+    if (!raw)
+        return [];
+    return raw
+        .split(",")
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+}