@zapier/zapier-sdk-cli 0.6.3 → 0.6.4

package/package.json

@@ -1,13 +1,24 @@
 {
   "name": "@zapier/zapier-sdk-cli",
-  "version": "0.6.3",
+  "version": "0.6.4",
   "description": "Command line interface for Zapier SDK",
-  "type": "module",
-  "main": "dist/index.js",
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.cjs"
+      },
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      }
+    }
+  },
   "bin": {
-    "zapier-sdk": "./bin/zapier-sdk.js",
-    "zsdk": "./bin/zsdk.js"
+    "zapier-sdk": "./bin/zapier-sdk.mjs"
   },
   "keywords": [
     "zapier",
@@ -31,9 +42,9 @@
     "ora": "^8.2.0",
     "pkce-challenge": "^5.0.0",
     "zod": "^3.25.67",
-    "@zapier/zapier-sdk": "0.6.3",
-    "@zapier/zapier-sdk-mcp": "0.2.3",
-    "@zapier/zapier-sdk-cli-login": "0.3.2"
+    "@zapier/zapier-sdk": "0.6.4",
+    "@zapier/zapier-sdk-cli-login": "0.3.2",
+    "@zapier/zapier-sdk-mcp": "0.2.4"
   },
   "devDependencies": {
     "@types/express": "^5.0.3",

package/src/cli.ts

@@ -1,45 +1,32 @@
 #!/usr/bin/env node
 
 import { Command } from "commander";
-import { createZapierSdk } from "@zapier/zapier-sdk";
 import { generateCliCommands } from "./utils/cli-generator";
-import {
-  createLoginCommand,
-  createLogoutCommand,
-  createConfigPathCommand,
-  createGenerateTypesCommand,
-  createBundleCodeCommand,
-  createMcpCommand,
-} from "./commands/index";
+import { createZapierCliSdk } from "./sdk";
+import packageJson from "../package.json" with { type: "json" };
 
 const program = new Command();
 
 program
   .name("zapier-sdk")
   .description("CLI for Zapier SDK")
-  .version("1.0.0")
+  .version(packageJson.version, "-v, --version", "display version number")
   .option("--debug", "Enable debug logging");
 
 // Check for debug flag early
 const isDebugMode =
   process.env.DEBUG === "true" || process.argv.includes("--debug");
 
-// Create SDK instance - automatically handles token resolution
-const sdk = createZapierSdk({
+// Create CLI SDK instance with all plugins
+const sdk = createZapierCliSdk({
   debug: isDebugMode,
 });
 
-// Add auth commands before generating SDK commands
-program.addCommand(createLoginCommand());
-program.addCommand(createLogoutCommand());
+// Auth commands now handled by plugins
 
-// Generate CLI commands from SDK schemas
+// Generate CLI commands from SDK schemas (including CLI plugins)
 generateCliCommands(program, sdk);
 
-// Add build-time commands (CLI-specific, not from SDK)
-program.addCommand(createGenerateTypesCommand());
-program.addCommand(createBundleCodeCommand());
-program.addCommand(createConfigPathCommand());
-program.addCommand(createMcpCommand());
+// MCP command now handled by plugin
 
 program.parse();

package/src/index.ts

@@ -1,2 +1,4 @@
 // Main exports for the CLI package
+export { createZapierCliSdk, type ZapierCliSdkOptions } from "./sdk";
+
 // All CLI functionality is now schema-driven via generateCLICommands

package/src/{commands/bundle-code → plugins/bundleCode}/index.ts

@@ -1,8 +1,45 @@
-import type { BundleCodeOptions } from "./schemas";
+import type { Plugin } from "@zapier/zapier-sdk";
+import { BundleCodeSchema, type BundleCodeOptions } from "./schemas";
+import { createFunction } from "@zapier/zapier-sdk";
 import { buildSync } from "esbuild";
 import * as fs from "fs";
 import * as path from "path";
 
+export interface BundleCodePluginProvides {
+  bundleCode: (options: BundleCodeOptions) => Promise<string>;
+  context: {
+    meta: {
+      bundleCode: {
+        inputSchema: typeof BundleCodeSchema;
+      };
+    };
+  };
+}
+
+export const bundleCodePlugin: Plugin<
+  {}, // requires no existing SDK methods
+  {}, // requires no context
+  BundleCodePluginProvides
+> = () => {
+  const bundleCodeWithSdk = createFunction(async function bundleCodeWithSdk(
+    options: BundleCodeOptions,
+  ): Promise<string> {
+    return await bundleCode(options);
+  }, BundleCodeSchema);
+
+  return {
+    bundleCode: bundleCodeWithSdk,
+    context: {
+      meta: {
+        bundleCode: {
+          categories: ["utility"],
+          inputSchema: BundleCodeSchema,
+        },
+      },
+    },
+  };
+};
+
 class ZapierBundleError extends Error {
   public readonly code = "ZAPIER_BUNDLE_ERROR";
   public readonly details?: string[];
@@ -19,7 +56,7 @@ class ZapierBundleError extends Error {
 /**
  * Bundle TypeScript code into executable JavaScript (CLI version)
  */
-export async function bundleCode(options: BundleCodeOptions): Promise<string> {
+async function bundleCode(options: BundleCodeOptions): Promise<string> {
   const {
     input,
     output,

package/src/{commands/bundle-code → plugins/bundleCode}/schemas.ts

@@ -10,13 +10,13 @@ export const BundleCodeSchema = z
     ),
     string: z
       .boolean()
-      .default(false)
+      .optional()
       .describe("Return bundled code as string instead of writing to file"),
-    minify: z.boolean().default(false).describe("Minify the bundled output"),
-    target: z.string().default("es2017").describe("ECMAScript target version"),
+    minify: z.boolean().optional().describe("Minify the bundled output"),
+    target: z.string().optional().describe("ECMAScript target version"),
     cjs: z
       .boolean()
-      .default(false)
+      .optional()
       .describe("Output CommonJS format instead of ESM"),
   })
   .describe("Bundle TypeScript code into executable JavaScript");

package/src/{commands/generate-types → plugins/generateTypes}/index.ts

@@ -2,12 +2,59 @@ import type {
   Action,
   ActionField,
   ActionItem,
-  createZapierSdk,
+  Plugin,
+  GetSdkType,
+  ListActionsPluginProvides,
+  ListInputFieldsPluginProvides,
+  ManifestPluginProvides,
 } from "@zapier/zapier-sdk";
-import type { GenerateTypesOptions } from "./schemas";
+import { GenerateTypesSchema, type GenerateTypesOptions } from "./schemas";
+import { createFunction } from "@zapier/zapier-sdk";
 import * as fs from "fs";
 import * as path from "path";
 
+export interface GenerateTypesPluginProvides {
+  generateTypes: (options: GenerateTypesOptions) => Promise<string>;
+  context: {
+    meta: {
+      generateTypes: {
+        inputSchema: typeof GenerateTypesSchema;
+      };
+    };
+  };
+}
+
+export const generateTypesPlugin: Plugin<
+  GetSdkType<
+    ListActionsPluginProvides &
+      ListInputFieldsPluginProvides &
+      ManifestPluginProvides
+  >, // requires these SDK methods
+  {}, // requires no context
+  GenerateTypesPluginProvides
+> = ({ sdk }) => {
+  const generateTypesWithSdk = createFunction(
+    async function generateTypesWithSdk(
+      options: GenerateTypesOptions,
+    ): Promise<string> {
+      return await generateTypes({ ...options, sdk });
+    },
+    GenerateTypesSchema,
+  );
+
+  return {
+    generateTypes: generateTypesWithSdk,
+    context: {
+      meta: {
+        generateTypes: {
+          categories: ["utility"],
+          inputSchema: GenerateTypesSchema,
+        },
+      },
+    },
+  };
+};
+
 interface ActionWithActionFields extends Omit<Action, "inputFields" | "type"> {
   inputFields: ActionField[];
   app_key: string;
@@ -28,7 +75,13 @@ function generateFetchMethodSignature(): string {
  * Generate TypeScript types for a specific app (CLI version)
  */
 export async function generateTypes(
-  options: GenerateTypesOptions & { sdk: ReturnType<typeof createZapierSdk> },
+  options: GenerateTypesOptions & {
+    sdk: GetSdkType<
+      ListActionsPluginProvides &
+        ListInputFieldsPluginProvides &
+        ManifestPluginProvides
+    >;
+  },
 ): Promise<string> {
   const {
     appKey,

package/src/{commands/generate-types → plugins/generateTypes}/schemas.ts

@@ -3,7 +3,6 @@ import {
   AppKeyPropertySchema,
   AuthenticationIdPropertySchema,
   OutputPropertySchema,
-  DebugPropertySchema,
 } from "@zapier/zapier-sdk";
 
 // Generate types schema - mirrors the original from SDK but for CLI use
@@ -14,9 +13,6 @@ export const GenerateTypesSchema = z
     output: OutputPropertySchema.optional().describe(
       "Output file path (defaults to generated/<appKey>.ts)",
     ),
-    debug: DebugPropertySchema.describe(
-      "Enable debug logging during generation",
-    ),
     lockFilePath: z
       .string()
       .optional()

package/src/plugins/getConfigPath/index.ts

@@ -0,0 +1,42 @@
+import type { Plugin } from "@zapier/zapier-sdk";
+import { GetConfigPathSchema, type GetConfigPathOptions } from "./schemas";
+import { createFunction } from "@zapier/zapier-sdk";
+import { getConfigPath } from "@zapier/zapier-sdk-cli-login";
+
+export interface GetConfigPathPluginProvides {
+  getConfigPath: (options?: GetConfigPathOptions) => Promise<string>;
+  context: {
+    meta: {
+      getConfigPath: {
+        inputSchema: typeof GetConfigPathSchema;
+      };
+    };
+  };
+}
+
+export const getConfigPathPlugin: Plugin<
+  {}, // requires no existing SDK methods
+  {}, // requires no context
+  GetConfigPathPluginProvides
+> = () => {
+  const getConfigPathWithSdk = createFunction(
+    async function getConfigPathWithSdk(
+      _options?: GetConfigPathOptions,
+    ): Promise<string> {
+      return getConfigPath();
+    },
+    GetConfigPathSchema,
+  );
+
+  return {
+    getConfigPath: getConfigPathWithSdk,
+    context: {
+      meta: {
+        getConfigPath: {
+          categories: ["utility"],
+          inputSchema: GetConfigPathSchema,
+        },
+      },
+    },
+  };
+};

package/src/plugins/getConfigPath/schemas.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+
+// Get config path schema - simple command with no parameters
+export const GetConfigPathSchema = z
+  .object({})
+  .describe("Show the path to the configuration file");
+
+export type GetConfigPathOptions = z.infer<typeof GetConfigPathSchema>;

package/src/plugins/index.ts

@@ -0,0 +1,6 @@
+export { loginPlugin } from "./login";
+export { logoutPlugin } from "./logout";
+export { mcpPlugin } from "./mcp";
+export { generateTypesPlugin } from "./generateTypes";
+export { bundleCodePlugin } from "./bundleCode";
+export { getConfigPathPlugin } from "./getConfigPath";

package/src/plugins/login/index.ts

@@ -0,0 +1,48 @@
+import { createFunction } from "@zapier/zapier-sdk";
+import type { Plugin } from "@zapier/zapier-sdk";
+import login from "../../utils/auth/login";
+import { getLoggedInUser } from "@zapier/zapier-sdk-cli-login";
+import { LoginSchema, type LoginOptions } from "./schemas";
+
+interface LoginPluginProvides {
+  login: (options: LoginOptions) => Promise<void>;
+  context: {
+    meta: {
+      login: {
+        inputSchema: typeof LoginSchema;
+        categories: string[];
+      };
+    };
+  };
+}
+
+const loginWithSdk = createFunction(async function loginWithSdk(
+  options: LoginOptions,
+): Promise<void> {
+  const timeoutSeconds = options.timeout ? parseInt(options.timeout, 10) : 300;
+  if (isNaN(timeoutSeconds) || timeoutSeconds <= 0) {
+    throw new Error("Timeout must be a positive number");
+  }
+
+  await login(timeoutSeconds * 1000); // Convert to milliseconds
+  const user = await getLoggedInUser();
+
+  console.log(`✅ Successfully logged in as ${user.email}`);
+
+  // Force immediate exit to prevent hanging (especially in development with tsx)
+  setTimeout(() => process.exit(0), 100);
+}, LoginSchema);
+
+export const loginPlugin: Plugin<{}, {}, LoginPluginProvides> = () => ({
+  login: loginWithSdk,
+  context: {
+    meta: {
+      login: {
+        categories: ["account"],
+        inputSchema: LoginSchema,
+      },
+    },
+  },
+});
+
+export type { LoginPluginProvides };

package/src/plugins/login/schemas.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+
+// Login schema
+export const LoginSchema = z
+  .object({
+    timeout: z
+      .string()
+      .optional()
+      .describe("Login timeout in seconds (default: 300)"),
+  })
+  .describe("Log in to Zapier to access your account");
+
+export type LoginOptions = z.infer<typeof LoginSchema>;

package/src/plugins/logout/index.ts

@@ -0,0 +1,37 @@
+import { createFunction } from "@zapier/zapier-sdk";
+import type { Plugin } from "@zapier/zapier-sdk";
+import { logout } from "@zapier/zapier-sdk-cli-login";
+import { LogoutSchema, type LogoutOptions } from "./schemas";
+
+interface LogoutPluginProvides {
+  logout: (options: LogoutOptions) => Promise<void>;
+  context: {
+    meta: {
+      logout: {
+        inputSchema: typeof LogoutSchema;
+        categories: string[];
+      };
+    };
+  };
+}
+
+const logoutWithSdk = createFunction(async function logoutWithSdk(
+  _options: LogoutOptions,
+): Promise<void> {
+  logout();
+  console.log("✅ Successfully logged out");
+}, LogoutSchema);
+
+export const logoutPlugin: Plugin<{}, {}, LogoutPluginProvides> = () => ({
+  logout: logoutWithSdk,
+  context: {
+    meta: {
+      logout: {
+        categories: ["account"],
+        inputSchema: LogoutSchema,
+      },
+    },
+  },
+});
+
+export type { LogoutPluginProvides };

package/src/plugins/logout/schemas.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+
+// Logout schema (no parameters needed)
+export const LogoutSchema = z
+  .object({})
+  .describe("Log out of your Zapier account");
+
+export type LogoutOptions = z.infer<typeof LogoutSchema>;

package/src/plugins/mcp/index.ts

@@ -0,0 +1,43 @@
+import { createFunction } from "@zapier/zapier-sdk";
+import type { Plugin } from "@zapier/zapier-sdk";
+import { startMcpServerAsProcess } from "@zapier/zapier-sdk-mcp";
+import { McpSchema, type McpOptions } from "./schemas";
+
+interface McpPluginProvides {
+  mcp: (options: McpOptions) => Promise<void>;
+  context: {
+    meta: {
+      mcp: {
+        inputSchema: typeof McpSchema;
+        categories: string[];
+      };
+    };
+  };
+}
+
+export const mcpPlugin: Plugin<{}, {}, McpPluginProvides> = ({ context }) => {
+  const mcpWithSdk = createFunction(async function mcpWithSdk(
+    options: McpOptions,
+  ): Promise<void> {
+    // Pass through the SDK's debug option to the MCP server
+    const mcpOptions = {
+      ...options,
+      debug: context.options.debug,
+    };
+    return await startMcpServerAsProcess(mcpOptions);
+  }, McpSchema);
+
+  return {
+    mcp: mcpWithSdk,
+    context: {
+      meta: {
+        mcp: {
+          categories: ["utility"],
+          inputSchema: McpSchema,
+        },
+      },
+    },
+  };
+};
+
+export type { McpPluginProvides };

package/src/plugins/mcp/schemas.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+
+// MCP server schema
+export const McpSchema = z
+  .object({
+    port: z
+      .string()
+      .optional()
+      .describe("Port to listen on (for future HTTP transport)"),
+  })
+  .describe("Start MCP server for Zapier SDK");
+
+export type McpOptions = z.infer<typeof McpSchema>;

package/src/sdk.ts

@@ -0,0 +1,43 @@
+import {
+  createZapierSdkWithoutRegistry,
+  registryPlugin,
+  type ZapierSdk,
+} from "@zapier/zapier-sdk";
+import {
+  loginPlugin,
+  logoutPlugin,
+  mcpPlugin,
+  generateTypesPlugin,
+  bundleCodePlugin,
+  getConfigPathPlugin,
+} from "./plugins/index";
+
+export interface ZapierCliSdkOptions {
+  debug?: boolean;
+}
+
+/**
+ * Create a Zapier SDK instance configured specifically for the CLI
+ * Includes all CLI-specific plugins in addition to the standard SDK functionality
+ */
+export function createZapierCliSdk(
+  options: ZapierCliSdkOptions = {},
+): ZapierSdk {
+  // Create SDK instance without registry
+  let sdk = createZapierSdkWithoutRegistry({
+    debug: options.debug,
+  });
+
+  // Add CLI-specific plugins before registry
+  sdk = sdk.addPlugin(generateTypesPlugin);
+  sdk = sdk.addPlugin(bundleCodePlugin);
+  sdk = sdk.addPlugin(getConfigPathPlugin);
+  sdk = sdk.addPlugin(mcpPlugin);
+  sdk = sdk.addPlugin(loginPlugin);
+  sdk = sdk.addPlugin(logoutPlugin);
+
+  // Add registry plugin to finalize SDK
+  const finalSdk = sdk.addPlugin(registryPlugin);
+
+  return finalSdk;
+}

package/src/utils/cli-generator.ts

@@ -18,6 +18,11 @@ import inquirer from "inquirer";
 // ============================================================================
 
 function formatJsonOutput(data: unknown): void {
+  // Don't print anything for undefined results (commands that just perform actions)
+  if (data === undefined) {
+    return;
+  }
+
   // Show success message for action results
   if (
     data &&

package/tsconfig.build.json

@@ -1,6 +1,18 @@
 {
-  "extends": "./tsconfig.json",
   "compilerOptions": {
-    "paths": {}
-  }
+    "target": "ES2020",
+    "module": "esnext",
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "bundler"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["dist", "node_modules", "src/**/*.test.ts", "src/**/*.spec.ts"]
 }

package/tsconfig.json

@@ -1,7 +1,7 @@
 {
   "compilerOptions": {
     "target": "ES2020",
-    "module": "ES2020",
+    "module": "esnext",
     "moduleResolution": "bundler",
     "strict": true,
     "noUnusedLocals": true,
@@ -13,7 +13,7 @@
     "outDir": "./dist",
     "composite": true
   },
-  "include": ["src/**/*"],
+  "include": ["src/**/*", "package.json"],
   "exclude": ["node_modules", "dist", "**/*.test.ts"],
   "references": [{ "path": "../zapier-sdk" }]
 }

package/tsup.config.ts

@@ -2,16 +2,22 @@ import { defineConfig } from "tsup";
 
 export default defineConfig({
   entry: ["src/index.ts", "src/cli.ts"],
-  format: ["esm"],
-  dts: false,
+  format: ["cjs", "esm"],
+  dts: true,
   clean: true,
   splitting: false,
   sourcemap: false,
+  // Preserve tree shaking by maintaining individual module exports
+  treeshake: true,
+  // Output to separate directories for each format
   outDir: "dist",
-  // Keep as .js for Node.js compatibility since package.json has type: module
   outExtension({ format }) {
     return {
-      js: ".js",
+      js: format === "cjs" ? ".cjs" : ".mjs",
     };
   },
+  // Make the optional CLI login package external so it doesn't cause build issues
+  external: ["@zapier/zapier-sdk-cli-login"],
+  // Use the build-specific tsconfig for tsup
+  tsconfig: "tsconfig.build.json",
 });

package/bin/zsdk.js

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-
-// Import the CLI from the compiled TypeScript
-import "../dist/cli.js";

package/dist/src/commands/bundle-code/cli.d.ts

@@ -1,2 +0,0 @@
-import { Command } from "commander";
-export declare function createBundleCodeCommand(): Command;