@zapier/zapier-sdk-cli 0.1.1 → 0.2.1

package/src/utils/auth/login.ts

@@ -0,0 +1,190 @@
+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";
+
+const findAvailablePort = (): Promise<number> => {
+  return new Promise((resolve, reject) => {
+    let portIndex = 0;
+
+    const tryPort = (port: number) => {
+      const server = express().listen(port, () => {
+        server.close();
+        resolve(port);
+      });
+
+      server.on("error", (err: NodeJS.ErrnoException) => {
+        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: number = LOGIN_TIMEOUT_MS): Promise<string> => {
+  // 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<string>();
+
+  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<any>();
+  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<string>((_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<void>((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<{
+    access_token: string;
+    refresh_token: string;
+    expires_in: number;
+  }>(
+    `${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/src/utils/constants.ts

@@ -0,0 +1,9 @@
+export const ZAPIER_BASE = "https://zapier.com";
+
+// OAuth client ID for zapier-sdk CLI
+export const LOGIN_CLIENT_ID = "K5eEnRE9TTmSFATdkkWhKF8NOKwoiOnYAyIqJjae";
+
+export const LOGIN_PORTS = [49505, 50575, 52804, 55981, 61010, 63851];
+export const LOGIN_TIMEOUT_MS = 300000; // 5 minutes
+
+export const AUTH_MODE_HEADER = "X-Auth";

package/src/utils/getCallablePromise.ts

@@ -0,0 +1,21 @@
+const getCallablePromise = <T>(): {
+  promise: Promise<T>;
+  resolve: (value: T) => void;
+  reject: (reason: unknown) => void;
+} => {
+  let resolve: (value: T) => void = () => {};
+  let reject: (reason: unknown) => void = () => {};
+
+  const promise = new Promise<T>((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+
+  return {
+    promise,
+    resolve,
+    reject,
+  };
+};
+
+export default getCallablePromise;

package/src/utils/log.ts

@@ -0,0 +1,18 @@
+import chalk from "chalk";
+
+const log = {
+  info: (message: string, ...args: any[]) => {
+    console.log(chalk.blue("ℹ"), message, ...args);
+  },
+  error: (message: string, ...args: any[]) => {
+    console.error(chalk.red("✖"), message, ...args);
+  },
+  success: (message: string, ...args: any[]) => {
+    console.log(chalk.green("✓"), message, ...args);
+  },
+  warn: (message: string, ...args: any[]) => {
+    console.log(chalk.yellow("⚠"), message, ...args);
+  },
+};
+
+export default log;

package/src/utils/serializeAsync.ts

@@ -0,0 +1,26 @@
+import { createHash } from "node:crypto";
+
+const promises: Record<string, Promise<unknown>> = {};
+
+const serializeAsync =
+  <R, A extends []>(
+    fn: (...args: A) => Promise<R>,
+  ): ((...args: A) => Promise<R>) =>
+  async (...args: A): Promise<R> => {
+    const hash = createHash("sha256")
+      .update(fn.toString(), "utf8")
+      .digest()
+      .toString("hex");
+
+    const promise = promises[hash];
+
+    if (!promise) {
+      promises[hash] = fn(...args).finally(() => {
+        delete promises[hash];
+      });
+    }
+
+    return promises[hash] as Promise<R>;
+  };
+
+export default serializeAsync;

package/src/utils/spinner.ts

@@ -0,0 +1,16 @@
+import ora from "ora";
+
+export const spinPromise = async <T>(
+  promise: Promise<T>,
+  text: string,
+): Promise<T> => {
+  const spinner = ora(text).start();
+  try {
+    const result = await promise;
+    spinner.succeed();
+    return result;
+  } catch (error) {
+    spinner.fail();
+    throw error;
+  }
+};

package/tsconfig.json

@@ -1,8 +1,8 @@
 {
   "compilerOptions": {
     "target": "ES2020",
-    "module": "CommonJS",
-    "moduleResolution": "node",
+    "module": "ES2020",
+    "moduleResolution": "bundler",
     "strict": true,
     "noUnusedLocals": true,
     "noUnusedParameters": true,