@zapier/zapier-sdk-cli 0.4.0 → 0.4.2

package/dist/src/commands/login.js

@@ -0,0 +1,25 @@
+import { Command } from "commander";
+import login from "../utils/auth/login";
+import { getLoggedInUser } from "@zapier/zapier-sdk-cli-login";
+export function createLoginCommand() {
+    return new Command("login")
+        .description("Log in to Zapier to access your account")
+        .option("--timeout <seconds>", "Login timeout in seconds (default: 300)", "300")
+        .action(async (options) => {
+        try {
+            const timeoutSeconds = parseInt(options.timeout, 10);
+            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);
+        }
+        catch (error) {
+            console.error("❌ Login failed:", error instanceof Error ? error.message : "Unknown error");
+            process.exit(1);
+        }
+    });
+}

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

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

package/dist/src/commands/logout.js

@@ -0,0 +1,16 @@
+import { Command } from "commander";
+import { logout } from "@zapier/zapier-sdk-cli-login";
+export function createLogoutCommand() {
+    return new Command("logout")
+        .description("Log out of your Zapier account")
+        .action(async () => {
+        try {
+            logout();
+            console.log("✅ Successfully logged out");
+        }
+        catch (error) {
+            console.error("❌ Logout failed:", error instanceof Error ? error.message : "Unknown error");
+            process.exit(1);
+        }
+    });
+}

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

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

package/dist/src/commands/mcp.js

@@ -0,0 +1,11 @@
+import { Command } from "commander";
+import { startMcpServerAsProcess } from "@zapier/zapier-sdk-mcp";
+export function createMcpCommand() {
+    const command = new Command("mcp");
+    command
+        .description("Start MCP server for Zapier SDK")
+        .option("--debug", "Enable debug logging")
+        .option("--port <port>", "Port to listen on (for future HTTP transport)")
+        .action(startMcpServerAsProcess);
+    return command;
+}

package/dist/src/index.js

@@ -0,0 +1,3 @@
+"use strict";
+// Main exports for the CLI package
+// All CLI functionality is now schema-driven via generateCLICommands

package/dist/src/utils/api/client.d.ts

@@ -0,0 +1,15 @@
+export interface ApiResponse<T = any> {
+    data: T;
+    status: number;
+}
+export declare const createApiClient: () => {
+    post: <T = any>(url: string, data: any, options?: {
+        headers?: Record<string, string>;
+    }) => Promise<ApiResponse<T>>;
+};
+declare const api: {
+    post: <T = any>(url: string, data: any, options?: {
+        headers?: Record<string, string>;
+    }) => Promise<ApiResponse<T>>;
+};
+export default api;

package/dist/src/utils/api/client.js

@@ -0,0 +1,27 @@
+export const createApiClient = () => {
+    const post = async (url, data, options = {}) => {
+        const { headers = {} } = options;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/x-www-form-urlencoded",
+                Connection: "close",
+                ...headers,
+            },
+            body: new URLSearchParams(data),
+        });
+        if (!response.ok) {
+            throw new Error(`${response.status} ${response.statusText}`);
+        }
+        const responseData = await response.json();
+        return {
+            data: responseData,
+            status: response.status,
+        };
+    };
+    return {
+        post,
+    };
+};
+const api = createApiClient();
+export default api;

package/dist/src/utils/auth/login.d.ts

@@ -0,0 +1,2 @@
+declare const login: (timeoutMs?: number) => Promise<string>;
+export default login;

package/dist/src/utils/auth/login.js

@@ -0,0 +1,134 @@
+import open from "open";
+import crypto from "node:crypto";
+import express from "express";
+import pkceChallenge from "pkce-challenge";
+import { AUTH_MODE_HEADER, LOGIN_CLIENT_ID, LOGIN_PORTS, LOGIN_TIMEOUT_MS, ZAPIER_BASE, } from "../constants";
+import { spinPromise } from "../spinner";
+import log from "../log";
+import api from "../api/client";
+import getCallablePromise from "../getCallablePromise";
+import { updateLogin, logout } from "@zapier/zapier-sdk-cli-login";
+const findAvailablePort = () => {
+    return new Promise((resolve, reject) => {
+        let portIndex = 0;
+        const tryPort = (port) => {
+            const server = express().listen(port, () => {
+                server.close();
+                resolve(port);
+            });
+            server.on("error", (err) => {
+                if (err.code === "EADDRINUSE") {
+                    if (portIndex < LOGIN_PORTS.length) {
+                        // Try next predefined port
+                        tryPort(LOGIN_PORTS[portIndex++]);
+                    }
+                    else {
+                        // All configured ports are busy
+                        reject(new Error(`All configured OAuth callback ports are busy: ${LOGIN_PORTS.join(", ")}. Please try again later or close applications using these ports.`));
+                    }
+                }
+                else {
+                    reject(err);
+                }
+            });
+        };
+        if (LOGIN_PORTS.length > 0) {
+            tryPort(LOGIN_PORTS[portIndex++]);
+        }
+        else {
+            reject(new Error("No OAuth callback ports configured"));
+        }
+    });
+};
+const generateRandomString = () => {
+    const array = new Uint32Array(28);
+    crypto.getRandomValues(array);
+    return Array.from(array, (dec) => ("0" + dec.toString(16)).substring(-2)).join("");
+};
+const login = async (timeoutMs = LOGIN_TIMEOUT_MS) => {
+    // Force logout
+    logout();
+    // Find an available port
+    const availablePort = await findAvailablePort();
+    const redirectUri = `http://localhost:${availablePort}/oauth`;
+    log.info(`Using port ${availablePort} for OAuth callback`);
+    const { promise: promisedCode, resolve: setCode } = getCallablePromise();
+    const app = express();
+    app.get("/oauth", (req, res) => {
+        setCode(String(req.query.code));
+        // Set headers to prevent keep-alive
+        res.setHeader("Connection", "close");
+        res.end("You can now close this tab and return to the CLI.");
+    });
+    const server = app.listen(availablePort);
+    // Track connections to force close them if needed
+    const connections = new Set();
+    server.on("connection", (conn) => {
+        connections.add(conn);
+        conn.on("close", () => connections.delete(conn));
+    });
+    // Set up signal handlers for graceful shutdown
+    const cleanup = () => {
+        server.close();
+        log.info("\n❌ Login cancelled by user");
+        process.exit(0);
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    const { code_verifier: codeVerifier, code_challenge: codeChallenge } = await pkceChallenge();
+    const authUrl = `${ZAPIER_BASE}/oauth/authorize/?${new URLSearchParams({
+        response_type: "code",
+        client_id: LOGIN_CLIENT_ID,
+        redirect_uri: redirectUri,
+        scope: "internal offline_access",
+        state: generateRandomString(),
+        code_challenge: codeChallenge,
+        code_challenge_method: "S256",
+    }).toString()}`;
+    log.info("Opening your browser to log in.");
+    log.info("If it doesn't open, visit:", authUrl);
+    open(authUrl);
+    try {
+        await spinPromise(Promise.race([
+            promisedCode,
+            new Promise((_resolve, reject) => setTimeout(() => {
+                reject(new Error(`Login timed out after ${Math.round(timeoutMs / 1000)} seconds.`));
+            }, timeoutMs)),
+        ]), "Waiting for you to login and authorize");
+    }
+    finally {
+        // Remove signal handlers
+        process.off("SIGINT", cleanup);
+        process.off("SIGTERM", cleanup);
+        // Close server with timeout and force-close connections if needed
+        await new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+                log.info("Server close timed out, forcing connection shutdown...");
+                // Force close all connections
+                connections.forEach((conn) => conn.destroy());
+                resolve();
+            }, 1000); // 1 second timeout
+            server.close(() => {
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    }
+    log.info("Exchanging authorization code for tokens...");
+    const { data } = await api.post(`${ZAPIER_BASE}/oauth/token/`, {
+        grant_type: "authorization_code",
+        code: await promisedCode,
+        redirect_uri: redirectUri,
+        client_id: LOGIN_CLIENT_ID,
+        code_verifier: codeVerifier,
+    }, {
+        headers: {
+            [AUTH_MODE_HEADER]: "no",
+            "Content-Type": "application/x-www-form-urlencoded",
+        },
+    });
+    updateLogin(data);
+    log.info("Token exchange completed successfully");
+    return data.access_token;
+};
+export default login;

package/dist/src/utils/cli-generator-utils.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export interface CliParameter {
+    name: string;
+    type: "string" | "number" | "boolean" | "array";
+    required: boolean;
+    description?: string;
+    default?: any;
+    choices?: string[];
+    hasResolver?: boolean;
+    isPositional?: boolean;
+}
+export declare function analyzeZodSchema(schema: z.ZodSchema): CliParameter[];
+export declare function convertCliArgsToSdkParams(parameters: CliParameter[], positionalArgs: any[], options: Record<string, any>): Record<string, any>;

package/dist/src/utils/cli-generator-utils.js

@@ -0,0 +1,116 @@
+import { z } from "zod";
+import { hasResolver, isPositional } from "@zapier/zapier-sdk";
+// ============================================================================
+// Schema Analysis
+// ============================================================================
+export function analyzeZodSchema(schema) {
+    const parameters = [];
+    if (schema instanceof z.ZodObject) {
+        const shape = schema.shape;
+        for (const [key, fieldSchema] of Object.entries(shape)) {
+            const param = analyzeZodField(key, fieldSchema);
+            if (param) {
+                parameters.push(param);
+            }
+        }
+    }
+    return parameters;
+}
+function analyzeZodField(name, schema) {
+    let baseSchema = schema;
+    let required = true;
+    let defaultValue = undefined;
+    // Unwrap optional and default wrappers
+    if (baseSchema instanceof z.ZodOptional) {
+        required = false;
+        baseSchema = baseSchema._def.innerType;
+    }
+    if (baseSchema instanceof z.ZodDefault) {
+        required = false;
+        defaultValue = baseSchema._def.defaultValue();
+        baseSchema = baseSchema._def.innerType;
+    }
+    // Determine parameter type
+    let paramType = "string";
+    let choices;
+    if (baseSchema instanceof z.ZodString) {
+        paramType = "string";
+    }
+    else if (baseSchema instanceof z.ZodNumber) {
+        paramType = "number";
+    }
+    else if (baseSchema instanceof z.ZodBoolean) {
+        paramType = "boolean";
+    }
+    else if (baseSchema instanceof z.ZodArray) {
+        paramType = "array";
+    }
+    else if (baseSchema instanceof z.ZodEnum) {
+        paramType = "string";
+        choices = baseSchema._def.values;
+    }
+    else if (baseSchema instanceof z.ZodRecord) {
+        // Handle Record<string, any> as JSON string input
+        paramType = "string";
+    }
+    // Extract resolver metadata
+    return {
+        name,
+        type: paramType,
+        required,
+        description: schema.description,
+        default: defaultValue,
+        choices,
+        hasResolver: hasResolver(name),
+        isPositional: isPositional(schema),
+    };
+}
+// ============================================================================
+// Parameter Conversion
+// ============================================================================
+export function convertCliArgsToSdkParams(parameters, positionalArgs, options) {
+    const sdkParams = {};
+    // Handle positional arguments (required parameters or optional positional parameters)
+    let argIndex = 0;
+    parameters.forEach((param) => {
+        if ((param.required || param.isPositional) &&
+            argIndex < positionalArgs.length) {
+            // Use the original camelCase parameter name for the SDK
+            sdkParams[param.name] = convertValue(positionalArgs[argIndex], param.type);
+            argIndex++;
+        }
+    });
+    // Handle option flags
+    Object.entries(options).forEach(([key, value]) => {
+        // Convert kebab-case back to camelCase
+        const camelKey = key.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
+        const param = parameters.find((p) => p.name === camelKey);
+        if (param && value !== undefined) {
+            sdkParams[camelKey] = convertValue(value, param.type);
+        }
+    });
+    return sdkParams;
+}
+function convertValue(value, type) {
+    switch (type) {
+        case "number":
+            return Number(value);
+        case "boolean":
+            return Boolean(value);
+        case "array":
+            return Array.isArray(value) ? value : [value];
+        case "string":
+        default:
+            // Handle JSON string for objects
+            if (typeof value === "string" &&
+                (value.startsWith("{") || value.startsWith("["))) {
+                try {
+                    return JSON.parse(value);
+                }
+                catch {
+                    return value;
+                }
+            }
+            return value;
+    }
+}

package/dist/src/utils/cli-generator.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+import { ZapierSdk } from "@zapier/zapier-sdk";
+export declare function generateCliCommands(program: Command, sdk: ZapierSdk): void;