@zapier/zapier-sdk-cli 0.1.0 → 0.2.0

package/dist/cli.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const commander_1 = require("commander");
-const zapier_sdk_1 = require("@zapier/zapier-sdk");
-const cli_generator_1 = require("./utils/cli-generator");
-const program = new commander_1.Command();
+import { Command } from "commander";
+import { createZapierSdk } from "@zapier/zapier-sdk";
+import { generateCliCommands } from "./utils/cli-generator";
+import { ensureValidToken } from "./utils/auth/ensureValidToken";
+import { createLoginCommand, createLogoutCommand, createWhoamiCommand, createConfigPathCommand, } from "./commands";
+const program = new Command();
 program
     .name("zapier-sdk")
     .description("CLI for Zapier SDK - Commands auto-generated from SDK schemas")
@@ -12,12 +12,16 @@ program
     .option("--debug", "Enable debug logging");
 // Check for debug flag early
 const isDebugMode = process.env.DEBUG === "true" || process.argv.includes("--debug");
-// Create SDK instance for CLI operations
-// Auth will be resolved from environment variables or command options
-const sdk = (0, zapier_sdk_1.createZapierSdk)({
-    // Token will be picked up from ZAPIER_TOKEN env var or provided via options
+// Create SDK instance with dynamic token resolution
+const sdk = createZapierSdk({
+    getToken: ensureValidToken,
     debug: isDebugMode,
 });
+// Add auth commands before generating SDK commands
+program.addCommand(createLoginCommand());
+program.addCommand(createLogoutCommand());
+program.addCommand(createWhoamiCommand());
+program.addCommand(createConfigPathCommand());
 // Generate CLI commands from SDK schemas
-(0, cli_generator_1.generateCliCommands)(program, sdk);
+generateCliCommands(program, sdk);
 program.parse();

package/dist/commands/configPath.d.ts

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

package/dist/commands/configPath.js

@@ -0,0 +1,9 @@
+import { Command } from "commander";
+import { getConfigPath } from "../utils/getConfigPath";
+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/commands/index.d.ts

@@ -0,0 +1,4 @@
+export { createLoginCommand } from "./login";
+export { createLogoutCommand } from "./logout";
+export { createWhoamiCommand } from "./whoami";
+export { createConfigPathCommand } from "./configPath";

package/dist/commands/index.js

@@ -0,0 +1,4 @@
+export { createLoginCommand } from "./login";
+export { createLogoutCommand } from "./logout";
+export { createWhoamiCommand } from "./whoami";
+export { createConfigPathCommand } from "./configPath";

package/dist/commands/login.d.ts

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

package/dist/commands/login.js

@@ -0,0 +1,25 @@
+import { Command } from "commander";
+import login from "../utils/auth/login";
+import getLoggedInUser from "../utils/auth/getLoggedInUser";
+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/commands/logout.d.ts

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

package/dist/commands/logout.js

@@ -0,0 +1,16 @@
+import { Command } from "commander";
+import logout from "../utils/auth/logout";
+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/commands/whoami.d.ts

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

package/dist/commands/whoami.js

@@ -0,0 +1,16 @@
+import { Command } from "commander";
+import getLoggedInUser from "../utils/auth/getLoggedInUser";
+export function createWhoamiCommand() {
+    return new Command("whoami")
+        .description("Show current login status and user information")
+        .action(async () => {
+        try {
+            const user = await getLoggedInUser();
+            console.log(`✅ Logged in as ${user.email} (Account ID: ${user.accountId})`);
+        }
+        catch {
+            console.log("❌ Not logged in. Use 'zapier-sdk login' to authenticate.");
+            process.exit(1);
+        }
+    });
+}

package/dist/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/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/utils/auth/ensureValidToken.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Ensures we have a valid, non-expired JWT token.
+ * Will attempt to refresh expired tokens automatically.
+ * Falls back to ZAPIER_TOKEN environment variable if no stored login.
+ * Returns undefined if no token is available or refresh fails.
+ */
+export declare const ensureValidToken: () => Promise<string | undefined>;

package/dist/utils/auth/ensureValidToken.js

@@ -0,0 +1,33 @@
+import getAuthState from "./getAuthState";
+import refreshJWT from "./refreshJWT";
+/**
+ * Ensures we have a valid, non-expired JWT token.
+ * Will attempt to refresh expired tokens automatically.
+ * Falls back to ZAPIER_TOKEN environment variable if no stored login.
+ * Returns undefined if no token is available or refresh fails.
+ */
+export const ensureValidToken = async () => {
+    try {
+        const state = getAuthState();
+        if (state.status === "logged-out") {
+            // Fall back to environment variable if not logged in
+            return process.env.ZAPIER_TOKEN;
+        }
+        if (state.status === "expired") {
+            // Attempt to refresh the token
+            try {
+                return await refreshJWT();
+            }
+            catch {
+                // If refresh fails, fall back to environment variable
+                return process.env.ZAPIER_TOKEN;
+            }
+        }
+        // Status is "logged-in", return the valid token
+        return state.jwt;
+    }
+    catch {
+        // If any error occurs, fall back to environment variable
+        return process.env.ZAPIER_TOKEN;
+    }
+};

package/dist/utils/auth/getAuthState.d.ts

@@ -0,0 +1,12 @@
+type Status = {
+    status: "logged-in";
+    jwt: string;
+    refresh_token: string;
+} | {
+    status: "expired";
+    refresh_token: string;
+} | {
+    status: "logged-out";
+};
+declare const getAuthState: () => Status;
+export default getAuthState;

package/dist/utils/auth/getAuthState.js

@@ -0,0 +1,17 @@
+import { config } from "../config";
+const getAuthState = () => {
+    const jwt = config.get("login_jwt");
+    const refreshToken = config.get("login_refresh_token");
+    const expiresAt = config.get("login_expires_at");
+    if (!jwt || !refreshToken || !expiresAt) {
+        return { status: "logged-out" };
+    }
+    if (expiresAt > Date.now() + 30 * 1000) {
+        return { status: "logged-in", jwt, refresh_token: refreshToken };
+    }
+    return {
+        status: "expired",
+        refresh_token: refreshToken,
+    };
+};
+export default getAuthState;

package/dist/utils/auth/getJWT.d.ts

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

package/dist/utils/auth/getJWT.js

@@ -0,0 +1,13 @@
+import getAuthState from "./getAuthState";
+import refreshJWT from "./refreshJWT";
+const getJWT = async () => {
+    const state = getAuthState();
+    if (state.status === "logged-out") {
+        throw new Error("Expected getJWT to only be called when user has logged in.");
+    }
+    if (state.status === "expired") {
+        return await refreshJWT();
+    }
+    return state.jwt;
+};
+export default getJWT;

package/dist/utils/auth/getLoggedInUser.d.ts

@@ -0,0 +1,6 @@
+declare const getLoggedInUser: () => Promise<{
+    accountId: number;
+    customUserId: number;
+    email: string;
+}>;
+export default getLoggedInUser;

package/dist/utils/auth/getLoggedInUser.js

@@ -0,0 +1,47 @@
+import jsonwebtoken from "jsonwebtoken";
+import getJWT from "./getJWT";
+const decodeJWTOrThrow = (jwt) => {
+    if (typeof jwt !== "string") {
+        throw new Error("Expected JWT to be a string");
+    }
+    const decodedJWT = jsonwebtoken.decode(jwt, { 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;
+};
+const getLoggedInUser = async () => {
+    const jwt = await getJWT();
+    let decodedJwt = decodeJWTOrThrow(jwt);
+    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,
+    };
+};
+export default getLoggedInUser;

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

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

package/dist/utils/auth/login.js

@@ -0,0 +1,135 @@
+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 from "./updateLogin";
+import logout from "./logout";
+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/utils/auth/logout.d.ts

@@ -0,0 +1,2 @@
+declare const logout: () => void;
+export default logout;

package/dist/utils/auth/logout.js

@@ -0,0 +1,7 @@
+import { config } from "../config";
+const logout = () => {
+    config.delete("login_jwt");
+    config.delete("login_refresh_token");
+    config.delete("login_expires_at");
+};
+export default logout;

package/dist/utils/auth/refreshJWT.d.ts

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

package/dist/utils/auth/refreshJWT.js

@@ -0,0 +1,33 @@
+import { AUTH_MODE_HEADER, LOGIN_CLIENT_ID, ZAPIER_BASE } from "../constants";
+import api from "../api/client";
+import serializeAsync from "../serializeAsync";
+import { spinPromise } from "../spinner";
+import getAuthState from "./getAuthState";
+import updateLogin from "./updateLogin";
+import logout from "./logout";
+const refreshJWT = async () => {
+    const state = getAuthState();
+    if (state.status === "logged-out") {
+        throw new Error("Unexpected call to refreshJWT while logged out.");
+    }
+    try {
+        const { data } = await spinPromise(api.post(`${ZAPIER_BASE}/oauth/token/`, {
+            client_id: LOGIN_CLIENT_ID,
+            refresh_token: state.refresh_token,
+            grant_type: "refresh_token",
+        }, {
+            headers: {
+                "Content-Type": "application/x-www-form-urlencoded",
+                [AUTH_MODE_HEADER]: "no",
+            },
+        }), "Refreshing your token...");
+        updateLogin(data);
+        return data.access_token;
+    }
+    catch (e) {
+        // Force logout
+        logout();
+        throw e;
+    }
+};
+export default serializeAsync(refreshJWT);

package/dist/utils/auth/updateLogin.d.ts

@@ -0,0 +1,7 @@
+interface LoginData {
+    access_token: string;
+    refresh_token: string;
+    expires_in: number;
+}
+declare const updateLogin: ({ access_token: accessToken, refresh_token: refreshToken, expires_in: expiresIn, }: LoginData) => void;
+export default updateLogin;

package/dist/utils/auth/updateLogin.js

@@ -0,0 +1,7 @@
+import { config } from "../config";
+const updateLogin = ({ access_token: accessToken, refresh_token: refreshToken, expires_in: expiresIn, }) => {
+    config.set("login_jwt", accessToken);
+    config.set("login_refresh_token", refreshToken);
+    config.set("login_expires_at", Date.now() + expiresIn * 1000);
+};
+export default updateLogin;