@zapier/zapier-sdk-cli 0.4.0 → 0.4.2

package/dist/src/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/src/cli.js

@@ -0,0 +1,28 @@
+#!/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";
+const program = new Command();
+program
+    .name("zapier-sdk")
+    .description("CLI for Zapier SDK - Commands auto-generated from SDK schemas")
+    .version("1.0.0")
+    .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({
+    debug: isDebugMode,
+});
+// Add auth commands before generating SDK commands
+program.addCommand(createLoginCommand());
+program.addCommand(createLogoutCommand());
+// Generate CLI commands from SDK schemas
+generateCliCommands(program, sdk);
+// Add build-time commands (CLI-specific, not from SDK)
+program.addCommand(createGenerateTypesCommand());
+program.addCommand(createBundleCodeCommand());
+program.addCommand(createConfigPathCommand());
+program.addCommand(createMcpCommand());
+program.parse();

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

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

package/dist/src/commands/bundle-code/cli.js

@@ -0,0 +1,77 @@
+import { Command } from "commander";
+import { BundleCodeSchema } from "./schemas";
+import { bundleCode } from "./index";
+import chalk from "chalk";
+import { analyzeZodSchema, convertCliArgsToSdkParams, } from "../../utils/cli-generator-utils";
+export function createBundleCodeCommand() {
+    const parameters = analyzeZodSchema(BundleCodeSchema);
+    const description = BundleCodeSchema.description ||
+        "Bundle TypeScript code into executable JavaScript";
+    const command = new Command("bundle-code").description(description);
+    // Add parameters to command using same logic as CLI generator
+    parameters.forEach((param) => {
+        // Convert camelCase to kebab-case for CLI display
+        const kebabName = param.name.replace(/([A-Z])/g, "-$1").toLowerCase();
+        if (param.hasResolver && param.required) {
+            // Required parameters with resolvers become optional positional arguments (resolver handles prompting)
+            command.argument(`[${kebabName}]`, param.description || `${kebabName} parameter`);
+        }
+        else if (param.required) {
+            // Required parameters without resolvers become required positional arguments
+            command.argument(`<${kebabName}>`, param.description || `${kebabName} parameter`);
+        }
+        else if (param.isPositional) {
+            // Optional parameters marked as positional become optional positional arguments
+            command.argument(`[${kebabName}]`, param.description || `${kebabName} parameter`);
+        }
+        else {
+            // Optional parameters become flags (whether they have resolvers or not)
+            const flags = [`--${kebabName}`];
+            if (param.type === "boolean") {
+                command.option(flags.join(", "), param.description);
+            }
+            else {
+                const flagSignature = flags.join(", ") + ` <${param.type}>`;
+                command.option(flagSignature, param.description, param.default);
+            }
+        }
+    });
+    // Add formatting options like other commands
+    command.option("--json", "Output raw JSON instead of formatted results");
+    command.action(async (...args) => {
+        try {
+            // The last argument is always the command object with parsed options
+            const commandObj = args[args.length - 1];
+            const options = commandObj.opts();
+            // Convert CLI args to SDK method parameters
+            const rawParams = convertCliArgsToSdkParams(parameters, args.slice(0, -1), options);
+            // No parameter resolution needed for bundle-code since it doesn't use SDK
+            if (!rawParams.input) {
+                throw new Error("Input file path is required");
+            }
+            console.log(chalk.blue(`📦 Bundling ${rawParams.input}...`));
+            // Call our implementation
+            const result = await bundleCode(rawParams);
+            if (options.json) {
+                console.log(JSON.stringify({ result }, null, 2));
+            }
+            else if (rawParams.output && !rawParams.string) {
+                console.log(chalk.green("✅ Bundle created successfully!"));
+                console.log(chalk.gray(`Output written to: ${rawParams.output}`));
+            }
+            else if (rawParams.string) {
+                console.log(chalk.green("✅ Bundle generated as string!"));
+                console.log("\n" + result);
+            }
+            else {
+                console.log(chalk.green("✅ Bundle completed!"));
+                console.log("\n" + result);
+            }
+        }
+        catch (error) {
+            console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+            process.exit(1);
+        }
+    });
+    return command;
+}

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

@@ -0,0 +1,5 @@
+import type { BundleCodeOptions } from "./schemas";
+/**
+ * Bundle TypeScript code into executable JavaScript (CLI version)
+ */
+export declare function bundleCode(options: BundleCodeOptions): Promise<string>;

package/dist/src/commands/bundle-code/index.js

@@ -0,0 +1,62 @@
+import { buildSync } from "esbuild";
+import * as fs from "fs";
+import * as path from "path";
+class ZapierBundleError extends Error {
+    constructor(message, details, originalError) {
+        super(message);
+        this.code = "ZAPIER_BUNDLE_ERROR";
+        this.name = "ZapierBundleError";
+        this.details = details;
+        this.originalError = originalError;
+    }
+}
+/**
+ * Bundle TypeScript code into executable JavaScript (CLI version)
+ */
+export async function bundleCode(options) {
+    const { input, output, target = "es2020", cjs = false, minify = false, string: returnString = false, } = options;
+    // Resolve input path
+    const resolvedInput = path.resolve(process.cwd(), input);
+    try {
+        // Bundle with esbuild
+        const result = buildSync({
+            entryPoints: [resolvedInput],
+            bundle: true,
+            platform: "node",
+            target: target,
+            format: cjs ? "cjs" : "esm",
+            minify: minify,
+            write: false,
+            external: [], // Bundle everything
+            banner: {
+                js: "#!/usr/bin/env node",
+            },
+        });
+        if (result.errors.length > 0) {
+            const errorMessages = result.errors.map((e) => e.text);
+            throw new ZapierBundleError(`Bundle failed: ${errorMessages.join(", ")}`, errorMessages);
+        }
+        const bundledCode = result.outputFiles?.[0]?.text;
+        if (!bundledCode) {
+            throw new ZapierBundleError("No output generated");
+        }
+        let finalOutput = bundledCode;
+        if (returnString) {
+            // Output as quoted string for node -e using JSON.stringify
+            finalOutput = JSON.stringify(bundledCode);
+        }
+        // Write to file if output path specified
+        if (output) {
+            fs.mkdirSync(path.dirname(output), { recursive: true });
+            fs.writeFileSync(output, finalOutput, "utf8");
+        }
+        return finalOutput;
+    }
+    catch (error) {
+        // If it's already a ZapierBundleError, re-throw as-is
+        if (error instanceof ZapierBundleError) {
+            throw error;
+        }
+        throw new ZapierBundleError(`Bundle failed: ${error instanceof Error ? error.message : "Unknown error"}`, undefined, error instanceof Error ? error : undefined);
+    }
+}

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

@@ -0,0 +1,24 @@
+import { z } from "zod";
+export declare const BundleCodeSchema: z.ZodObject<{
+    input: z.ZodString;
+    output: z.ZodOptional<z.ZodString>;
+    string: z.ZodDefault<z.ZodBoolean>;
+    minify: z.ZodDefault<z.ZodBoolean>;
+    target: z.ZodDefault<z.ZodString>;
+    cjs: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    string: boolean;
+    input: string;
+    minify: boolean;
+    target: string;
+    cjs: boolean;
+    output?: string | undefined;
+}, {
+    input: string;
+    string?: boolean | undefined;
+    output?: string | undefined;
+    minify?: boolean | undefined;
+    target?: string | undefined;
+    cjs?: boolean | undefined;
+}>;
+export type BundleCodeOptions = z.infer<typeof BundleCodeSchema>;

package/dist/src/commands/bundle-code/schemas.js

@@ -0,0 +1,19 @@
+import { z } from "zod";
+import { OutputPropertySchema } from "@zapier/zapier-sdk";
+// Bundle code schema - mirrors the original from SDK but for CLI use
+export const BundleCodeSchema = z
+    .object({
+    input: z.string().min(1).describe("Input TypeScript file path to bundle"),
+    output: OutputPropertySchema.optional().describe("Output file path (defaults to input with .js extension)"),
+    string: z
+        .boolean()
+        .default(false)
+        .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"),
+    cjs: z
+        .boolean()
+        .default(false)
+        .describe("Output CommonJS format instead of ESM"),
+})
+    .describe("Bundle TypeScript code into executable JavaScript");

package/dist/src/commands/configPath.d.ts

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

package/dist/src/commands/configPath.js

@@ -0,0 +1,9 @@
+import { Command } from "commander";
+import { getConfigPath } from "@zapier/zapier-sdk-cli-login";
+export function createConfigPathCommand() {
+    return new Command("get-config-path")
+        .description("Show the path to the configuration file")
+        .action(async () => {
+        console.log(`Configuration file: ${getConfigPath()}`);
+    });
+}

package/dist/src/commands/generate-types/cli.d.ts

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

package/dist/src/commands/generate-types/cli.js

@@ -0,0 +1,73 @@
+import { Command } from "commander";
+import { createZapierSdk } from "@zapier/zapier-sdk";
+import { GenerateTypesSchema } from "./schemas";
+import { generateTypes } from "./index";
+import chalk from "chalk";
+import { SchemaParameterResolver } from "../../utils/parameter-resolver";
+import { analyzeZodSchema, convertCliArgsToSdkParams, } from "../../utils/cli-generator-utils";
+export function createGenerateTypesCommand() {
+    const parameters = analyzeZodSchema(GenerateTypesSchema);
+    const description = GenerateTypesSchema.description ||
+        "Generate TypeScript SDK types for a specific app";
+    const command = new Command("generate-types").description(description);
+    // Add parameters to command using same logic as CLI generator
+    parameters.forEach((param) => {
+        // Convert camelCase to kebab-case for CLI display
+        const kebabName = param.name.replace(/([A-Z])/g, "-$1").toLowerCase();
+        if (param.hasResolver && param.required) {
+            // Required parameters with resolvers become optional positional arguments (resolver handles prompting)
+            command.argument(`[${kebabName}]`, param.description || `${kebabName} parameter`);
+        }
+        else if (param.required) {
+            // Required parameters without resolvers become required positional arguments
+            command.argument(`<${kebabName}>`, param.description || `${kebabName} parameter`);
+        }
+        else if (param.isPositional) {
+            // Optional parameters marked as positional become optional positional arguments
+            command.argument(`[${kebabName}]`, param.description || `${kebabName} parameter`);
+        }
+        else {
+            // Optional parameters become flags (whether they have resolvers or not)
+            const flags = [`--${kebabName}`];
+            if (param.type === "boolean") {
+                command.option(flags.join(", "), param.description);
+            }
+            else {
+                const flagSignature = flags.join(", ") + ` <${param.type}>`;
+                command.option(flagSignature, param.description, param.default);
+            }
+        }
+    });
+    // Add formatting options like other commands
+    command.option("--json", "Output raw JSON instead of formatted results");
+    command.action(async (...args) => {
+        try {
+            // The last argument is always the command object with parsed options
+            const commandObj = args[args.length - 1];
+            const options = commandObj.opts();
+            // Convert CLI args to SDK method parameters
+            const rawParams = convertCliArgsToSdkParams(parameters, args.slice(0, -1), options);
+            // Create SDK instance
+            const sdk = createZapierSdk();
+            // Resolve missing parameters interactively using schema metadata
+            const resolver = new SchemaParameterResolver();
+            const resolvedParams = await resolver.resolveParameters(GenerateTypesSchema, rawParams, sdk);
+            console.log(chalk.blue(`🔧 Generating TypeScript types for ${resolvedParams.appKey}...`));
+            // Call our implementation
+            const result = await generateTypes({ ...resolvedParams, sdk });
+            if (options.json) {
+                console.log(JSON.stringify({ result }, null, 2));
+            }
+            else {
+                const output = resolvedParams.output || `./types/${resolvedParams.appKey}.d.ts`;
+                console.log(chalk.green("✅ TypeScript types generated successfully!"));
+                console.log(chalk.gray(`Output written to: ${output}`));
+            }
+        }
+        catch (error) {
+            console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+            process.exit(1);
+        }
+    });
+    return command;
+}

package/dist/src/commands/generate-types/index.d.ts

@@ -0,0 +1,8 @@
+import type { createZapierSdk } from "@zapier/zapier-sdk";
+import type { GenerateTypesOptions } from "./schemas";
+/**
+ * Generate TypeScript types for a specific app (CLI version)
+ */
+export declare function generateTypes(options: GenerateTypesOptions & {
+    sdk: ReturnType<typeof createZapierSdk>;
+}): Promise<string>;

package/dist/src/commands/generate-types/index.js

@@ -0,0 +1,273 @@
+import * as fs from "fs";
+import * as path from "path";
+/**
+ * Generate the fetch method signature for app proxies
+ */
+function generateFetchMethodSignature() {
+    return `  /** Make authenticated HTTP requests through Zapier's Relay service */
+  fetch: (options: Omit<z.infer<typeof RelayFetchSchema>, 'authenticationId'>) => Promise<Response>`;
+}
+/**
+ * Generate TypeScript types for a specific app (CLI version)
+ */
+export async function generateTypes(options) {
+    const { appKey, authenticationId, output = `./types/${appKey}.d.ts`, sdk, } = options;
+    // Parse app identifier (support app@version format)
+    const { app, version } = parseAppIdentifier(appKey);
+    // Fetch all actions for the app
+    const actionsResult = await sdk.listActions({
+        appKey: app,
+    });
+    const actions = actionsResult.data;
+    if (actions.length === 0) {
+        const typeDefinitions = generateEmptyTypesFile(app, version);
+        if (output) {
+            fs.mkdirSync(path.dirname(output), { recursive: true });
+            fs.writeFileSync(output, typeDefinitions, "utf8");
+        }
+        return typeDefinitions;
+    }
+    // Fetch input fields for each action
+    const actionsWithFields = [];
+    if (authenticationId) {
+        for (const action of actions) {
+            try {
+                const fieldsResult = await sdk.listInputFields({
+                    appKey: action.app_key,
+                    actionKey: action.key,
+                    actionType: action.action_type,
+                    authenticationId: authenticationId,
+                });
+                const fields = fieldsResult.data; // Direct array result
+                actionsWithFields.push({ ...action, inputFields: fields });
+            }
+            catch {
+                // If we can't get fields for an action, include it without fields
+                actionsWithFields.push({ ...action, inputFields: [] });
+            }
+        }
+    }
+    else {
+        // Convert actions to have empty input fields (will generate generic types)
+        actions.forEach((action) => {
+            actionsWithFields.push({ ...action, inputFields: [] });
+        });
+    }
+    // Generate TypeScript types
+    const typeDefinitions = generateTypeDefinitions(app, actionsWithFields, version);
+    // Write to file if output path specified
+    if (output) {
+        fs.mkdirSync(path.dirname(output), { recursive: true });
+        fs.writeFileSync(output, typeDefinitions, "utf8");
+    }
+    return typeDefinitions;
+}
+function parseAppIdentifier(identifier) {
+    const parts = identifier.split("@");
+    return {
+        app: parts[0],
+        version: parts[1],
+    };
+}
+function generateTypeDefinitions(appKey, actions, version) {
+    // Handle empty actions
+    if (actions.length === 0) {
+        return generateEmptyTypesFile(appKey, version);
+    }
+    // Group actions by type
+    const actionsByType = actions.reduce((acc, action) => {
+        if (!acc[action.action_type]) {
+            acc[action.action_type] = [];
+        }
+        acc[action.action_type].push(action);
+        return acc;
+    }, {});
+    const appName = capitalize(appKey);
+    const versionComment = version
+        ? ` * Generated for ${appKey}@${version}`
+        : ` * Generated for ${appKey}`;
+    let output = `/* eslint-disable @typescript-eslint/naming-convention */
+/**
+ * Auto-generated TypeScript types for Zapier ${appKey} actions
+${versionComment}
+ * Generated on: ${new Date().toISOString()}
+ * 
+ * Usage:
+ *   import type { ${appName}Sdk } from './path/to/this/file'
+ *   const sdk = createZapierSdk() as unknown as ${appName}Sdk
+ *   
+ *   // Direct usage (per-call auth):
+ *   await sdk.apps.${appKey}.search.user_by_email({ authenticationId: 123, inputs: { email } })
+ *   
+ *   // Factory usage (pinned auth):
+ *   const my${appName} = sdk.apps.${appKey}({ authenticationId: 123 })
+ *   await my${appName}.search.user_by_email({ inputs: { email } })
+ */
+
+import type { ActionExecutionOptions, ActionExecutionResult } from '@zapier/zapier-sdk'
+import { z } from 'zod'
+import { RelayFetchSchema } from '@zapier/zapier-sdk'
+
+`;
+    // Generate input types for each action
+    actions.forEach((action) => {
+        if (action.inputFields.length > 0) {
+            const inputTypeName = `${appName}${capitalize(action.action_type)}${capitalize(sanitizeActionName(action.key))}Inputs`;
+            output += `interface ${inputTypeName} {\n`;
+            action.inputFields.forEach((field) => {
+                const isOptional = !field.required;
+                const fieldType = mapFieldTypeToTypeScript(field);
+                const description = field.helpText
+                    ? `  /** ${escapeComment(field.helpText)} */\n`
+                    : "";
+                output += `${description}  ${sanitizeFieldName(field.key)}${isOptional ? "?" : ""}: ${fieldType}\n`;
+            });
+            output += `}\n\n`;
+        }
+    });
+    // Generate action type interfaces for each action type
+    Object.entries(actionsByType).forEach(([actionType, typeActions]) => {
+        const typeName = `${appName}${capitalize(actionType)}Actions`;
+        output += `interface ${typeName} {\n`;
+        typeActions.forEach((action) => {
+            const actionName = sanitizeActionName(action.key);
+            const description = action.description
+                ? `  /** ${escapeComment(action.description)} */\n`
+                : "";
+            // Generate type-safe action method signature
+            if (action.inputFields.length > 0) {
+                const inputTypeName = `${appName}${capitalize(action.action_type)}${capitalize(sanitizeActionName(action.key))}Inputs`;
+                output += `${description}  ${actionName}: (options: { inputs: ${inputTypeName} } & Omit<ActionExecutionOptions, 'inputs'>) => Promise<ActionExecutionResult>\n`;
+            }
+            else {
+                // No specific input fields available - use generic Record<string, any> for inputs
+                output += `${description}  ${actionName}: (options?: { inputs?: Record<string, any> } & ActionExecutionOptions) => Promise<ActionExecutionResult>\n`;
+            }
+        });
+        output += `}\n\n`;
+    });
+    // Generate the main app SDK interface with factory pattern support
+    // Generate the app proxy interface (actions grouped by type)
+    output += `interface ${appName}AppProxy {\n`;
+    Object.keys(actionsByType).forEach((actionType) => {
+        const typeName = `${appName}${capitalize(actionType)}Actions`;
+        output += `  ${actionType}: ${typeName}\n`;
+    });
+    // Always include fetch method for authenticated HTTP requests
+    output += generateFetchMethodSignature() + "\n";
+    output += `}\n\n`;
+    // Generate the factory function interface
+    output += `interface ${appName}AppFactory {\n`;
+    output += `  (options: { authenticationId: number }): ${appName}AppProxy\n`;
+    output += `}\n\n`;
+    // Combine factory and direct access
+    output += `type ${appName}AppWithFactory = ${appName}AppFactory & ${appName}AppProxy\n\n`;
+    // Generate the main SDK interface
+    output += `export interface ${appName}Sdk {\n`;
+    output += `  apps: {\n`;
+    output += `    ${appKey}: ${appName}AppWithFactory\n`;
+    output += `  }\n`;
+    output += `}\n`;
+    return output;
+}
+function generateEmptyTypesFile(appKey, version) {
+    const appName = capitalize(appKey);
+    const versionComment = version
+        ? ` * Generated for ${appKey}@${version}`
+        : ` * Generated for ${appKey}`;
+    return `/* eslint-disable @typescript-eslint/naming-convention */
+/**
+ * Auto-generated TypeScript types for Zapier ${appKey} actions
+${versionComment}
+ * Generated on: ${new Date().toISOString()}
+ * 
+ * No actions found for this app.
+ */
+
+import type { ActionExecutionOptions, ActionExecutionResult } from '@zapier/zapier-sdk'
+import { z } from 'zod'
+import { RelayFetchSchema } from '@zapier/zapier-sdk'
+
+interface ${appName}AppProxy {
+  // No actions available
+${generateFetchMethodSignature()}
+}
+
+interface ${appName}AppFactory {
+  (options: { authenticationId: number }): ${appName}AppProxy
+}
+
+type ${appName}AppWithFactory = ${appName}AppFactory & ${appName}AppProxy
+
+export interface ${appName}Sdk {
+  apps: {
+    ${appKey}: ${appName}AppWithFactory
+  }
+}
+`;
+}
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1).replace(/[-_]/g, "");
+}
+function sanitizeActionName(actionKey) {
+    // Ensure the action name is a valid TypeScript identifier
+    let sanitized = actionKey.replace(/[^a-zA-Z0-9_$]/g, "_");
+    // If it starts with a number, prepend an underscore
+    if (/^[0-9]/.test(sanitized)) {
+        sanitized = "_" + sanitized;
+    }
+    return sanitized;
+}
+function sanitizeFieldName(fieldKey) {
+    // Ensure the field name is a valid TypeScript identifier
+    let sanitized = fieldKey.replace(/[^a-zA-Z0-9_$]/g, "_");
+    // If it starts with a number, prepend an underscore
+    if (/^[0-9]/.test(sanitized)) {
+        sanitized = "_" + sanitized;
+    }
+    return sanitized;
+}
+function escapeComment(comment) {
+    // Escape comment text to prevent breaking the JSDoc comment
+    return comment.replace(/\*\//g, "*\\/").replace(/\r?\n/g, " ");
+}
+function mapFieldTypeToTypeScript(field) {
+    // Handle choices (enum-like fields)
+    if (field.choices && field.choices.length > 0) {
+        const choiceValues = field.choices
+            .filter((choice) => choice.value !== undefined &&
+            choice.value !== null &&
+            choice.value !== "")
+            .map((choice) => typeof choice.value === "string" ? `"${choice.value}"` : choice.value);
+        if (choiceValues.length > 0) {
+            return choiceValues.join(" | ");
+        }
+        // If all choices were filtered out, fall through to default type handling
+    }
+    // Map Zapier field types to TypeScript types
+    switch (field.type?.toLowerCase()) {
+        case "string":
+        case "text":
+        case "email":
+        case "url":
+        case "password":
+            return "string";
+        case "integer":
+        case "number":
+            return "number";
+        case "boolean":
+            return "boolean";
+        case "datetime":
+        case "date":
+            return "string"; // ISO date strings
+        case "file":
+            return "string"; // File URL or content
+        case "array":
+            return "any[]";
+        case "object":
+            return "Record<string, any>";
+        default:
+            // Default to string for unknown types, with union for common cases
+            return "string | number | boolean";
+    }
+}

package/dist/src/commands/generate-types/schemas.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+export declare const GenerateTypesSchema: z.ZodObject<{
+    appKey: z.ZodString;
+    authenticationId: z.ZodOptional<z.ZodNumber>;
+    output: z.ZodOptional<z.ZodString>;
+    debug: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    appKey: string;
+    debug: boolean;
+    authenticationId?: number | undefined;
+    output?: string | undefined;
+}, {
+    appKey: string;
+    authenticationId?: number | undefined;
+    output?: string | undefined;
+    debug?: boolean | undefined;
+}>;
+export type GenerateTypesOptions = z.infer<typeof GenerateTypesSchema>;

package/dist/src/commands/generate-types/schemas.js

@@ -0,0 +1,11 @@
+import { z } from "zod";
+import { AppKeyPropertySchema, AuthenticationIdPropertySchema, OutputPropertySchema, DebugPropertySchema, } from "@zapier/zapier-sdk";
+// Generate types schema - mirrors the original from SDK but for CLI use
+export const GenerateTypesSchema = z
+    .object({
+    appKey: AppKeyPropertySchema.describe("App key to generate SDK code for"),
+    authenticationId: AuthenticationIdPropertySchema.optional(),
+    output: OutputPropertySchema.optional().describe("Output file path (defaults to generated/<appKey>.ts)"),
+    debug: DebugPropertySchema.describe("Enable debug logging during generation"),
+})
+    .describe("Generate TypeScript SDK code for a specific app");

package/dist/src/commands/index.d.ts

@@ -0,0 +1,6 @@
+export { createLoginCommand } from "./login";
+export { createLogoutCommand } from "./logout";
+export { createConfigPathCommand } from "./configPath";
+export { createGenerateTypesCommand } from "./generate-types/cli";
+export { createBundleCodeCommand } from "./bundle-code/cli";
+export { createMcpCommand } from "./mcp";

package/dist/src/commands/index.js

@@ -0,0 +1,6 @@
+export { createLoginCommand } from "./login";
+export { createLogoutCommand } from "./logout";
+export { createConfigPathCommand } from "./configPath";
+export { createGenerateTypesCommand } from "./generate-types/cli";
+export { createBundleCodeCommand } from "./bundle-code/cli";
+export { createMcpCommand } from "./mcp";

package/dist/src/commands/login.d.ts

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