zapier-platform-cli 18.0.5 → 18.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zapier-platform-cli",
-  "version": "18.0.5",
+  "version": "18.0.7",
   "description": "The CLI for managing integrations in Zapier Developer Platform.",
   "repository": "zapier/zapier-platform",
   "homepage": "https://platform.zapier.com/",
@@ -53,7 +53,7 @@
     "semver": "7.7.2",
     "string-length": "4.0.2",
     "through2": "4.0.2",
-    "tmp": "0.2.4",
+    "tmp": "0.2.5",
     "traverse": "0.6.11",
     "update-notifier": "7.3.1",
     "yeoman-environment": "4.4.3",
@@ -76,7 +76,20 @@
     "zapier-platform": "./src/bin/run"
   },
   "oclif": {
-    "commands": "src/oclif/commands",
+    "commands": {
+      "strategy": "pattern",
+      "target": "./src/oclif/commands",
+      "globPatterns": [
+        "**/*.js",
+        "!invoke/action.js",
+        "!invoke/env.js",
+        "!invoke/input-types.js",
+        "!invoke/logger.js",
+        "!invoke/prompts.js",
+        "!invoke/relay.js",
+        "!invoke/auth/**"
+      ]
+    },
     "additionalHelpFlags": [
       "-h"
     ],

package/src/oclif/commands/build.js

@@ -12,11 +12,11 @@ const colors = require('colors/safe');
 
 class BuildCommand extends BaseCommand {
   async perform() {
-    const skipNpmInstall = this.flags['skip-npm-install'];
+    const skipDepInstall = this.flags['skip-dep-install'];
     await buildAndOrUpload(
       { build: true },
       {
-        skipNpmInstall,
+        skipDepInstall,
         disableDependencyDetection: this.flags['disable-dependency-detection'],
         skipValidation: this.flags['skip-validation'],
       },
@@ -27,9 +27,9 @@ class BuildCommand extends BaseCommand {
         `Now you can upload them with the ${colors.bold.underline('zapier upload')} command.`,
     );
 
-    if (!skipNpmInstall) {
+    if (!skipDepInstall) {
       this.log(
-        `\nTip: Try ${colors.bold.underline('zapier build --skip-npm-install')} for faster builds.`,
+        `\nTip: Try ${colors.bold.underline('zapier build --skip-dep-install')} for faster builds.`,
       );
     }
   }
@@ -40,9 +40,10 @@ BuildCommand.flags = buildFlags({
     'disable-dependency-detection': Flags.boolean({
       description: `Disable "smart" file inclusion. By default, Zapier only includes files that are required by your entry point (\`index.js\` by default). If you (or your dependencies) require files dynamically (such as with \`require(someVar)\`), then you may see "Cannot find module" errors. Disabling this may make your \`build.zip\` too large. If that's the case, try using the \`includeInBuild\` option in your \`${CURRENT_APP_FILE}\`. See the docs about \`includeInBuild\` for more info.`,
     }),
-    'skip-npm-install': Flags.boolean({
+    'skip-dep-install': Flags.boolean({
+      aliases: ['skip-npm-install'],
       description:
-        'Skips installing a fresh copy of npm dependencies for shorter build time. Helpful for using yarn, pnpm, or local copies of dependencies.',
+        '[alias: --skip-npm-install]\nSkips installing a fresh copy of dependencies for shorter build time. Helpful for using yarn, pnpm, or local copies of dependencies.',
     }),
     'skip-validation': Flags.boolean({
       description:

package/src/oclif/commands/invoke/action.js

@@ -0,0 +1,91 @@
+const debug = require('debug')('zapier:invoke');
+
+const { startSpinner, endSpinner } = require('../../../utils/display');
+const { customLogger } = require('./logger');
+const { localAppCommandWithRelayErrorHandler } = require('./relay');
+const { promptForFields } = require('./prompts');
+const resolveInputDataTypes = require('./input-types');
+
+/**
+ * Invokes a trigger, create, or search action locally.
+ * Handles the full flow: prompting for input fields, resolving types, and executing the perform method.
+ * @param {import('../../ZapierBaseCommand')} command - The command instance for prompting
+ * @param {Object} context - The execution context containing app definition, auth data, input data, etc.
+ * @returns {Promise<*>} The action output
+ */
+const invokeAction = async (command, context) => {
+  // Do these in order:
+  // 1. Prompt for static input fields that alter dynamic fields
+  // 2. {actionTypePlural}.{actionKey}.operation.inputFields
+  // 3. Prompt for input fields again
+  // 4. {actionTypePlural}.{actionKey}.operation.perform
+  const action =
+    context.appDefinition[context.actionTypePlural][context.actionKey];
+  const staticInputFields = (action.operation.inputFields || []).filter(
+    (f) => f.key,
+  );
+  debug('staticInputFields:', staticInputFields);
+
+  await promptForFields(command, context, staticInputFields, invokeAction);
+
+  let methodName = `${context.actionTypePlural}.${action.key}.operation.inputFields`;
+  startSpinner(`Invoking ${methodName}`);
+
+  const inputFields = await localAppCommandWithRelayErrorHandler({
+    command: 'execute',
+    method: methodName,
+    bundle: {
+      inputData: context.inputData,
+      inputDataRaw: context.inputData, // At this point, inputData hasn't been transformed yet
+      authData: context.authData,
+      meta: context.meta,
+    },
+    zcacheTestObj: context.zcacheTestObj,
+    cursorTestObj: context.cursorTestObj,
+    customLogger,
+    calledFromCliInvoke: true,
+    appId: context.appId,
+    deployKey: context.deployKey,
+    relayAuthenticationId: context.authId,
+  });
+  endSpinner();
+
+  debug('inputFields:', inputFields);
+
+  if (inputFields.length !== staticInputFields.length) {
+    await promptForFields(command, context, inputFields, invokeAction);
+  }
+
+  // Preserve original inputData as inputDataRaw before type resolution
+  const inputDataRaw = { ...context.inputData };
+  const inputData = resolveInputDataTypes(
+    context.inputData,
+    inputFields,
+    context.timezone,
+  );
+  methodName = `${context.actionTypePlural}.${action.key}.operation.perform`;
+
+  startSpinner(`Invoking ${methodName}`);
+  const output = await localAppCommandWithRelayErrorHandler({
+    command: 'execute',
+    method: methodName,
+    bundle: {
+      inputData,
+      inputDataRaw,
+      authData: context.authData,
+      meta: context.meta,
+    },
+    zcacheTestObj: context.zcacheTestObj,
+    cursorTestObj: context.cursorTestObj,
+    customLogger,
+    calledFromCliInvoke: true,
+    appId: context.appId,
+    deployKey: context.deployKey,
+    relayAuthenticationId: context.authId,
+  });
+  endSpinner();
+
+  return output;
+};
+
+module.exports = { invokeAction };

package/src/oclif/commands/invoke/auth/index.js

@@ -0,0 +1,6 @@
+module.exports = {
+  startAuth: require('./start').startAuth,
+  testAuth: require('./test').testAuth,
+  getAuthLabel: require('./label').getAuthLabel,
+  refreshAuth: require('./refresh').refreshAuth,
+};

package/src/oclif/commands/invoke/auth/label.js

@@ -0,0 +1,22 @@
+const _ = require('lodash');
+
+const { testAuth } = require('./test');
+
+/**
+ * Gets the connection label by running authentication.test and rendering the label template.
+ * @param {Object} context - The execution context
+ * @returns {Promise<string>} The rendered connection label
+ */
+const getAuthLabel = async (context) => {
+  const testResult = await testAuth(context);
+  const labelTemplate = (
+    context.appDefinition.authentication.connectionLabel ?? ''
+  ).replaceAll('__', '.');
+  const tpl = _.template(labelTemplate, { interpolate: /{{([\s\S]+?)}}/g });
+  return tpl({
+    ...testResult,
+    bundle: { authData: context.authData, inputData: testResult },
+  });
+};
+
+module.exports = { getAuthLabel };

package/src/oclif/commands/invoke/auth/refresh.js

@@ -0,0 +1,87 @@
+const _ = require('lodash');
+
+const { localAppCommand } = require('../../../../utils/local');
+const { startSpinner, endSpinner } = require('../../../../utils/display');
+const { customLogger } = require('../logger');
+
+/**
+ * Refreshes OAuth2 access token using the refresh token.
+ * @param {Object} context - The execution context with current authData
+ * @returns {Promise<Object>} New auth data with refreshed tokens
+ */
+const refreshOAuth2 = async (context) => {
+  startSpinner('Invoking authentication.oauth2Config.refreshAccessToken');
+
+  const newAuthData = await localAppCommand({
+    command: 'execute',
+    method: 'authentication.oauth2Config.refreshAccessToken',
+    bundle: {
+      authData: context.authData,
+    },
+    zcacheTestObj: context.zcacheTestObj,
+    customLogger,
+    calledFromCliInvoke: true,
+  });
+
+  endSpinner();
+  return newAuthData;
+};
+
+/**
+ * Refreshes session authentication by calling the session config perform method.
+ * @param {Object} context - The execution context with current authData
+ * @returns {Promise<Object>} New session data
+ */
+const refreshSessionAuth = async (context) => {
+  startSpinner('Invoking authentication.sessionConfig.perform');
+
+  const sessionData = await localAppCommand({
+    command: 'execute',
+    method: 'authentication.sessionConfig.perform',
+    bundle: {
+      authData: context.authData,
+    },
+    zcacheTestObj: context.zcacheTestObj,
+    customLogger,
+    calledFromCliInvoke: true,
+  });
+
+  endSpinner();
+  return sessionData;
+};
+
+/**
+ * Main entry point for refreshing authentication.
+ * Routes to the appropriate refresh handler based on authentication type.
+ * @param {Object} context - The execution context
+ * @returns {Promise<Object|null>} New auth data or null if no authentication needed
+ * @throws {Error} If auth type doesn't support refresh or no auth data exists
+ */
+const refreshAuth = async (context) => {
+  const authentication = context.appDefinition.authentication;
+  if (!authentication) {
+    console.warn(
+      "Your integration doesn't seem to need authentication. " +
+        "If that isn't true, the app definition should have " +
+        'an `authentication` object at the root level.',
+    );
+    return null;
+  }
+  if (_.isEmpty(context.authData)) {
+    throw new Error(
+      'No auth data found in the .env file. Run `zapier invoke auth start` first to initialize the auth data.',
+    );
+  }
+  switch (authentication.type) {
+    case 'oauth2':
+      return refreshOAuth2(context);
+    case 'session':
+      return refreshSessionAuth(context);
+    default:
+      throw new Error(
+        `This command doesn't support refreshing authentication type "${authentication.type}".`,
+      );
+  }
+};
+
+module.exports = { refreshAuth };

package/src/oclif/commands/invoke/auth/start.js

@@ -0,0 +1,290 @@
+const crypto = require('node:crypto');
+const http = require('node:http');
+
+const _ = require('lodash');
+const debug = require('debug')('zapier:invoke');
+
+const { localAppCommand } = require('../../../../utils/local');
+const { startSpinner, endSpinner } = require('../../../../utils/display');
+const { appendEnv } = require('../env');
+const { customLogger } = require('../logger');
+const { formatFieldDisplay } = require('../prompts');
+
+/**
+ * Prompts the user for authentication field values.
+ * Handles password fields with hidden input.
+ * @param {import('../../../ZapierBaseCommand')} command - The command instance for prompting
+ * @param {Array<Object>} authFields - Array of auth field definitions
+ * @returns {Promise<Object>} Object containing field keys and user-provided values
+ */
+const promptForAuthFields = async (command, authFields) => {
+  const authData = {};
+  for (const field of authFields) {
+    if (field.computed) {
+      continue;
+    }
+    const message = formatFieldDisplay(field) + ':';
+    let value;
+    if (field.type === 'password') {
+      value = await command.promptHidden(message, true);
+    } else {
+      value = await command.prompt(message, { useStderr: true });
+    }
+    authData[field.key] = value;
+  }
+  return authData;
+};
+
+/**
+ * Initializes basic authentication by prompting for username and password.
+ * @param {import('../../../ZapierBaseCommand')} command - The command instance for prompting
+ * @param {Object} context - The execution context
+ * @returns {Promise<Object>} Auth data with username and password
+ * @throws {Error} If in non-interactive mode
+ */
+const startBasicAuth = async (command, context) => {
+  if (context.nonInteractive) {
+    throw new Error(
+      'The `auth start` subcommand for "basic" authentication type only works in interactive mode.',
+    );
+  }
+  return promptForAuthFields(command, [
+    {
+      key: 'username',
+      label: 'Username',
+      required: true,
+    },
+    {
+      key: 'password',
+      label: 'Password',
+      required: true,
+    },
+  ]);
+};
+
+/**
+ * Initializes custom authentication by prompting for configured auth fields.
+ * @param {import('../../../ZapierBaseCommand')} command - The command instance for prompting
+ * @param {Object} context - The execution context
+ * @returns {Promise<Object>} Auth data with field values
+ * @throws {Error} If in non-interactive mode
+ */
+const startCustomAuth = async (command, context) => {
+  if (context.nonInteractive) {
+    throw new Error(
+      'The `auth start` subcommand for "custom" authentication type only works in interactive mode.',
+    );
+  }
+  return promptForAuthFields(
+    command,
+    context.appDefinition.authentication.fields,
+  );
+};
+
+/**
+ * Initializes OAuth2 authentication.
+ * Prompts for CLIENT_ID/SECRET if needed, starts a local HTTP server,
+ * opens the browser for authorization, and exchanges the code for tokens.
+ * @param {import('../../../ZapierBaseCommand')} command - The command instance for prompting
+ * @param {Object} context - The execution context
+ * @returns {Promise<Object>} Auth data with access token and other OAuth2 fields
+ */
+const startOAuth2 = async (command, context) => {
+  const env = {};
+
+  if (!process.env.CLIENT_ID || !process.env.CLIENT_SECRET) {
+    if (context.nonInteractive) {
+      throw new Error(
+        'CLIENT_ID and CLIENT_SECRET must be set in the .env file in non-interactive mode.',
+      );
+    } else {
+      console.warn(
+        'CLIENT_ID and CLIENT_SECRET are required for OAuth2, ' +
+          "but they are not found in the .env file. I'll prompt you for them now.",
+      );
+    }
+  }
+
+  if (!process.env.CLIENT_ID) {
+    env.CLIENT_ID = await command.prompt('CLIENT_ID:', { useStderr: true });
+    process.env.CLIENT_ID = env.CLIENT_ID;
+  }
+  if (!process.env.CLIENT_SECRET) {
+    env.CLIENT_SECRET = await command.prompt('CLIENT_SECRET:', {
+      useStderr: true,
+    });
+    process.env.CLIENT_SECRET = env.CLIENT_SECRET;
+  }
+
+  if (!_.isEmpty(env)) {
+    // Save envs so the user won't have to re-enter them if the command fails
+    await appendEnv(env);
+    console.warn('CLIENT_ID and CLIENT_SECRET saved to .env file.');
+  }
+
+  startSpinner('Invoking authentication.oauth2Config.authorizeUrl');
+
+  const stateParam = crypto.randomBytes(20).toString('hex');
+  let authorizeUrl = await localAppCommand({
+    command: 'execute',
+    method: 'authentication.oauth2Config.authorizeUrl',
+    bundle: {
+      inputData: {
+        response_type: 'code',
+        redirect_uri: context.redirectUri,
+        state: stateParam,
+      },
+    },
+    zcacheTestObj: context.zcacheTestObj,
+    customLogger,
+    calledFromCliInvoke: true,
+  });
+  if (!authorizeUrl.includes('&scope=')) {
+    const scope = context.appDefinition.authentication.oauth2Config.scope;
+    if (scope) {
+      authorizeUrl += `&scope=${encodeURIComponent(scope)}`;
+    }
+  }
+  debug('authorizeUrl:', authorizeUrl);
+
+  endSpinner();
+  startSpinner('Starting local HTTP server');
+
+  let resolveCode;
+  const codePromise = new Promise((resolve) => {
+    resolveCode = resolve;
+  });
+
+  const server = http.createServer((req, res) => {
+    // Parse the request URL to extract the query parameters
+    const code = new URL(req.url, context.redirectUri).searchParams.get('code');
+    if (code) {
+      resolveCode(code);
+      debug(`Received code '${code}' from ${req.headers.referer}`);
+
+      res.writeHead(200, { 'Content-Type': 'text/plain' });
+      res.end(
+        'Parameter `code` received successfully. Go back to the terminal to continue.',
+      );
+    } else {
+      res.writeHead(400, { 'Content-Type': 'text/plain' });
+      res.end(
+        'Error: Did not receive `code` query parameter. ' +
+          'Did you have the right CLIENT_ID and CLIENT_SECRET? ' +
+          'Or did your server respond properly?',
+      );
+    }
+  });
+
+  await new Promise((resolve) => {
+    server.listen(context.port, resolve);
+  });
+
+  endSpinner();
+  startSpinner('Opening browser to authorize (press Ctrl-C to exit on error)');
+
+  const { default: open } = await import('open');
+  open(authorizeUrl);
+
+  const code = await codePromise;
+  endSpinner();
+
+  startSpinner('Closing local HTTP server');
+  await new Promise((resolve) => {
+    server.close(resolve);
+  });
+  debug('Local HTTP server closed');
+
+  endSpinner();
+  startSpinner('Invoking authentication.oauth2Config.getAccessToken');
+
+  const authData = await localAppCommand({
+    command: 'execute',
+    method: 'authentication.oauth2Config.getAccessToken',
+    bundle: {
+      authData: {},
+      inputData: {
+        code,
+        redirect_uri: context.redirectUri,
+      },
+    },
+    zcacheTestObj: context.zcacheTestObj,
+    customLogger,
+    calledFromCliInvoke: true,
+  });
+
+  endSpinner();
+  return authData;
+};
+
+/**
+ * Initializes session authentication.
+ * Prompts for auth fields and then calls the session config perform method.
+ * @param {import('../../../ZapierBaseCommand')} command - The command instance for prompting
+ * @param {Object} context - The execution context
+ * @returns {Promise<Object>} Combined auth data and session data
+ * @throws {Error} If in non-interactive mode
+ */
+const startSessionAuth = async (command, context) => {
+  if (context.nonInteractive) {
+    throw new Error(
+      'The `auth start` subcommand for "session" authentication type only works in interactive mode.',
+    );
+  }
+  const authData = await promptForAuthFields(
+    command,
+    context.appDefinition.authentication.fields,
+  );
+
+  startSpinner('Invoking authentication.sessionConfig.perform');
+  const sessionData = await localAppCommand({
+    command: 'execute',
+    method: 'authentication.sessionConfig.perform',
+    bundle: {
+      authData,
+    },
+    zcacheTestObj: context.zcacheTestObj,
+    customLogger,
+    calledFromCliInvoke: true,
+  });
+  endSpinner();
+
+  return { ...authData, ...sessionData };
+};
+
+/**
+ * Main entry point for initializing authentication.
+ * Routes to the appropriate auth type handler based on the app definition.
+ * @param {import('../../../ZapierBaseCommand')} command - The command instance for prompting
+ * @param {Object} context - The execution context
+ * @returns {Promise<Object|null>} Auth data or null if no authentication needed
+ * @throws {Error} If the authentication type is not supported
+ */
+const startAuth = async (command, context) => {
+  const authentication = context.appDefinition.authentication;
+  if (!authentication) {
+    console.warn(
+      "Your integration doesn't seem to need authentication. " +
+        "If that isn't true, the app definition should have " +
+        'an `authentication` object at the root level.',
+    );
+    return null;
+  }
+  switch (authentication.type) {
+    case 'basic':
+      return startBasicAuth(command, context);
+    case 'custom':
+      return startCustomAuth(command, context);
+    case 'oauth2':
+      return startOAuth2(command, context);
+    case 'session':
+      return startSessionAuth(command, context);
+    default:
+      // TODO: Add support for 'digest' and 'oauth1'
+      throw new Error(
+        `This command doesn't support authentication type "${authentication.type}".`,
+      );
+  }
+};
+
+module.exports = { startAuth };

package/src/oclif/commands/invoke/auth/test.js

@@ -0,0 +1,34 @@
+const { startSpinner, endSpinner } = require('../../../../utils/display');
+const { customLogger } = require('../logger');
+const { localAppCommandWithRelayErrorHandler } = require('../relay');
+
+/**
+ * Tests authentication by invoking the authentication.test method.
+ * Supports both local auth data and relay mode with production credentials.
+ * @param {Object} context - The execution context with authData and optional authId
+ * @returns {Promise<*>} The test result from the authentication.test method
+ */
+const testAuth = async (context) => {
+  startSpinner('Invoking authentication.test');
+  const result = await localAppCommandWithRelayErrorHandler({
+    command: 'execute',
+    method: 'authentication.test',
+    bundle: {
+      authData: context.authData,
+      meta: {
+        ...context.meta,
+        isTestingAuth: true,
+      },
+    },
+    zcacheTestObj: context.zcacheTestObj,
+    customLogger,
+    calledFromCliInvoke: true,
+    appId: context.appId,
+    deployKey: context.deployKey,
+    relayAuthenticationId: context.authId,
+  });
+  endSpinner();
+  return result;
+};
+
+module.exports = { testAuth };

package/src/oclif/commands/invoke/env.js

@@ -0,0 +1,62 @@
+const fsP = require('node:fs/promises');
+
+/** Prefix used for auth data fields in the .env file */
+const AUTH_FIELD_ENV_PREFIX = 'authData_';
+
+/**
+ * Loads authData from environment variables.
+ * Looks for variables prefixed with AUTH_FIELD_ENV_PREFIX and parses JSON values.
+ * @returns {Object} An object containing auth field keys and their values
+ */
+const loadAuthDataFromEnv = () => {
+  return Object.entries(process.env)
+    .filter(([k, v]) => k.startsWith(AUTH_FIELD_ENV_PREFIX))
+    .reduce((authData, [k, v]) => {
+      const fieldKey = k.substr(AUTH_FIELD_ENV_PREFIX.length);
+      // Try to parse as JSON if it looks like JSON, otherwise keep as string
+      try {
+        authData[fieldKey] =
+          v.startsWith('{') || v.startsWith('[') ? JSON.parse(v) : v;
+      } catch (e) {
+        // If JSON parsing fails, keep as string
+        authData[fieldKey] = v;
+      }
+      return authData;
+    }, {});
+};
+
+/**
+ * Appends variables to the .env file.
+ * Handles proper formatting and ensures newline separation.
+ * @param {Object} vars - Key-value pairs to append
+ * @param {string} [prefix=''] - Prefix to add to each variable name
+ * @returns {Promise<void>}
+ */
+const appendEnv = async (vars, prefix = '') => {
+  const envFile = '.env';
+  let content = Object.entries(vars)
+    .filter(([k, v]) => v !== undefined)
+    .map(
+      ([k, v]) =>
+        `${prefix}${k}='${typeof v === 'object' && v !== null ? JSON.stringify(v) : v || ''}'\n`,
+    )
+    .join('');
+
+  // Check if .env file exists and doesn't end with newline
+  try {
+    const existingContent = await fsP.readFile(envFile, 'utf8');
+    if (existingContent.length > 0 && !existingContent.endsWith('\n')) {
+      content = '\n' + content;
+    }
+  } catch (error) {
+    // File doesn't exist or can't be read, proceed as normal
+  }
+
+  await fsP.appendFile(envFile, content);
+};
+
+module.exports = {
+  AUTH_FIELD_ENV_PREFIX,
+  loadAuthDataFromEnv,
+  appendEnv,
+};