@zapier/zapier-sdk-cli 0.6.3 → 0.6.4

package/dist/index.cjs

@@ -0,0 +1,770 @@
+'use strict';
+
+var zapierSdk = require('@zapier/zapier-sdk');
+var open = require('open');
+var crypto = require('crypto');
+var express = require('express');
+var pkceChallenge = require('pkce-challenge');
+var ora = require('ora');
+var chalk = require('chalk');
+var zapierSdkCliLogin = require('@zapier/zapier-sdk-cli-login');
+var zod = require('zod');
+var zapierSdkMcp = require('@zapier/zapier-sdk-mcp');
+var fs = require('fs');
+var path = require('path');
+var esbuild = require('esbuild');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var open__default = /*#__PURE__*/_interopDefault(open);
+var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+var express__default = /*#__PURE__*/_interopDefault(express);
+var pkceChallenge__default = /*#__PURE__*/_interopDefault(pkceChallenge);
+var ora__default = /*#__PURE__*/_interopDefault(ora);
+var chalk__default = /*#__PURE__*/_interopDefault(chalk);
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+
+// src/sdk.ts
+
+// src/utils/constants.ts
+var ZAPIER_BASE = "https://zapier.com";
+var LOGIN_CLIENT_ID = "K5eEnRE9TTmSFATdkkWhKF8NOKwoiOnYAyIqJjae";
+var LOGIN_PORTS = [49505, 50575, 52804, 55981, 61010, 63851];
+var LOGIN_TIMEOUT_MS = 3e5;
+var AUTH_MODE_HEADER = "X-Auth";
+var spinPromise = async (promise, text) => {
+  const spinner = ora__default.default(text).start();
+  try {
+    const result = await promise;
+    spinner.succeed();
+    return result;
+  } catch (error) {
+    spinner.fail();
+    throw error;
+  }
+};
+var log = {
+  info: (message, ...args) => {
+    console.log(chalk__default.default.blue("\u2139"), message, ...args);
+  },
+  error: (message, ...args) => {
+    console.error(chalk__default.default.red("\u2716"), message, ...args);
+  },
+  success: (message, ...args) => {
+    console.log(chalk__default.default.green("\u2713"), message, ...args);
+  },
+  warn: (message, ...args) => {
+    console.log(chalk__default.default.yellow("\u26A0"), message, ...args);
+  }
+};
+var log_default = log;
+
+// src/utils/api/client.ts
+var 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
+  };
+};
+var api = createApiClient();
+var client_default = api;
+
+// src/utils/getCallablePromise.ts
+var getCallablePromise = () => {
+  let resolve2 = () => {
+  };
+  let reject = () => {
+  };
+  const promise = new Promise((_resolve, _reject) => {
+    resolve2 = _resolve;
+    reject = _reject;
+  });
+  return {
+    promise,
+    resolve: resolve2,
+    reject
+  };
+};
+var getCallablePromise_default = getCallablePromise;
+var findAvailablePort = () => {
+  return new Promise((resolve2, reject) => {
+    let portIndex = 0;
+    const tryPort = (port) => {
+      const server = express__default.default().listen(port, () => {
+        server.close();
+        resolve2(port);
+      });
+      server.on("error", (err) => {
+        if (err.code === "EADDRINUSE") {
+          if (portIndex < LOGIN_PORTS.length) {
+            tryPort(LOGIN_PORTS[portIndex++]);
+          } else {
+            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"));
+    }
+  });
+};
+var generateRandomString = () => {
+  const array = new Uint32Array(28);
+  crypto__default.default.getRandomValues(array);
+  return Array.from(
+    array,
+    (dec) => ("0" + dec.toString(16)).substring(-2)
+  ).join("");
+};
+var login = async (timeoutMs = LOGIN_TIMEOUT_MS) => {
+  zapierSdkCliLogin.logout();
+  const availablePort = await findAvailablePort();
+  const redirectUri = `http://localhost:${availablePort}/oauth`;
+  log_default.info(`Using port ${availablePort} for OAuth callback`);
+  const { promise: promisedCode, resolve: setCode } = getCallablePromise_default();
+  const app = express__default.default();
+  app.get("/oauth", (req, res) => {
+    setCode(String(req.query.code));
+    res.setHeader("Connection", "close");
+    res.end("You can now close this tab and return to the CLI.");
+  });
+  const server = app.listen(availablePort);
+  const connections = /* @__PURE__ */ new Set();
+  server.on("connection", (conn) => {
+    connections.add(conn);
+    conn.on("close", () => connections.delete(conn));
+  });
+  const cleanup = () => {
+    server.close();
+    log_default.info("\n\u274C Login cancelled by user");
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  const { code_verifier: codeVerifier, code_challenge: codeChallenge } = await pkceChallenge__default.default();
+  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_default.info("Opening your browser to log in.");
+  log_default.info("If it doesn't open, visit:", authUrl);
+  open__default.default(authUrl);
+  try {
+    await spinPromise(
+      Promise.race([
+        promisedCode,
+        new Promise(
+          (_resolve, reject) => setTimeout(() => {
+            reject(
+              new Error(
+                `Login timed out after ${Math.round(timeoutMs / 1e3)} seconds.`
+              )
+            );
+          }, timeoutMs)
+        )
+      ]),
+      "Waiting for you to login and authorize"
+    );
+  } finally {
+    process.off("SIGINT", cleanup);
+    process.off("SIGTERM", cleanup);
+    await new Promise((resolve2) => {
+      const timeout = setTimeout(() => {
+        log_default.info("Server close timed out, forcing connection shutdown...");
+        connections.forEach((conn) => conn.destroy());
+        resolve2();
+      }, 1e3);
+      server.close(() => {
+        clearTimeout(timeout);
+        resolve2();
+      });
+    });
+  }
+  log_default.info("Exchanging authorization code for tokens...");
+  const { data } = await client_default.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"
+      }
+    }
+  );
+  zapierSdkCliLogin.updateLogin(data);
+  log_default.info("Token exchange completed successfully");
+  return data.access_token;
+};
+var login_default = login;
+var LoginSchema = zod.z.object({
+  timeout: zod.z.string().optional().describe("Login timeout in seconds (default: 300)")
+}).describe("Log in to Zapier to access your account");
+
+// src/plugins/login/index.ts
+var loginWithSdk = zapierSdk.createFunction(async function loginWithSdk2(options) {
+  const timeoutSeconds = options.timeout ? parseInt(options.timeout, 10) : 300;
+  if (isNaN(timeoutSeconds) || timeoutSeconds <= 0) {
+    throw new Error("Timeout must be a positive number");
+  }
+  await login_default(timeoutSeconds * 1e3);
+  const user = await zapierSdkCliLogin.getLoggedInUser();
+  console.log(`\u2705 Successfully logged in as ${user.email}`);
+  setTimeout(() => process.exit(0), 100);
+}, LoginSchema);
+var loginPlugin = () => ({
+  login: loginWithSdk,
+  context: {
+    meta: {
+      login: {
+        categories: ["account"],
+        inputSchema: LoginSchema
+      }
+    }
+  }
+});
+var LogoutSchema = zod.z.object({}).describe("Log out of your Zapier account");
+
+// src/plugins/logout/index.ts
+var logoutWithSdk = zapierSdk.createFunction(async function logoutWithSdk2(_options) {
+  zapierSdkCliLogin.logout();
+  console.log("\u2705 Successfully logged out");
+}, LogoutSchema);
+var logoutPlugin = () => ({
+  logout: logoutWithSdk,
+  context: {
+    meta: {
+      logout: {
+        categories: ["account"],
+        inputSchema: LogoutSchema
+      }
+    }
+  }
+});
+var McpSchema = zod.z.object({
+  port: zod.z.string().optional().describe("Port to listen on (for future HTTP transport)")
+}).describe("Start MCP server for Zapier SDK");
+
+// src/plugins/mcp/index.ts
+var mcpPlugin = ({ context }) => {
+  const mcpWithSdk = zapierSdk.createFunction(async function mcpWithSdk2(options) {
+    const mcpOptions = {
+      ...options,
+      debug: context.options.debug
+    };
+    return await zapierSdkMcp.startMcpServerAsProcess(mcpOptions);
+  }, McpSchema);
+  return {
+    mcp: mcpWithSdk,
+    context: {
+      meta: {
+        mcp: {
+          categories: ["utility"],
+          inputSchema: McpSchema
+        }
+      }
+    }
+  };
+};
+var GenerateTypesSchema = zod.z.object({
+  appKey: zapierSdk.AppKeyPropertySchema.describe("App key to generate SDK code for"),
+  authenticationId: zapierSdk.AuthenticationIdPropertySchema.optional(),
+  output: zapierSdk.OutputPropertySchema.optional().describe(
+    "Output file path (defaults to generated/<appKey>.ts)"
+  ),
+  lockFilePath: zod.z.string().optional().describe("Path to the .zapierrc lock file (defaults to .zapierrc)")
+}).describe("Generate TypeScript SDK code for a specific app");
+var generateTypesPlugin = ({ sdk }) => {
+  const generateTypesWithSdk = zapierSdk.createFunction(
+    async function generateTypesWithSdk2(options) {
+      return await generateTypes({ ...options, sdk });
+    },
+    GenerateTypesSchema
+  );
+  return {
+    generateTypes: generateTypesWithSdk,
+    context: {
+      meta: {
+        generateTypes: {
+          categories: ["utility"],
+          inputSchema: GenerateTypesSchema
+        }
+      }
+    }
+  };
+};
+function generateFetchMethodSignature() {
+  return `  /** Make authenticated HTTP requests through Zapier's Relay service */
+  fetch: (options: Omit<z.infer<typeof RelayFetchSchema>, 'authenticationId'>) => Promise<Response>`;
+}
+async function generateTypes(options) {
+  const {
+    appKey,
+    authenticationId,
+    output = `./types/${appKey}.d.ts`,
+    sdk
+  } = options;
+  const { app, version } = parseAppIdentifier(appKey);
+  const actionsResult = await sdk.listActions({
+    appKey: app
+  });
+  const actions = actionsResult.data;
+  if (actions.length === 0) {
+    const typeDefinitions2 = generateEmptyTypesFile(app, version);
+    if (output) {
+      fs__namespace.mkdirSync(path__namespace.dirname(output), { recursive: true });
+      fs__namespace.writeFileSync(output, typeDefinitions2, "utf8");
+    }
+    return typeDefinitions2;
+  }
+  const actionsWithFields = [];
+  if (authenticationId) {
+    for (const action of actions) {
+      try {
+        const manifestEntry = sdk.getContext().getManifestEntry(appKey);
+        const fieldsResult = await sdk.listInputFields({
+          // If the appKey is in the manifest, use the appKey so that the types are consistent with the manifest's version, otherwise use the action.app_key
+          appKey: manifestEntry ? appKey : action.app_key,
+          actionKey: action.key,
+          actionType: action.action_type,
+          authenticationId
+        });
+        const fields = fieldsResult.data.map((field) => {
+          const fieldObj = field;
+          return {
+            ...fieldObj,
+            required: fieldObj.is_required || fieldObj.required || false
+          };
+        });
+        actionsWithFields.push({
+          ...action,
+          inputFields: fields,
+          name: action.title || action.key
+        });
+      } catch {
+        actionsWithFields.push({
+          ...action,
+          inputFields: [],
+          name: action.title || action.key
+        });
+      }
+    }
+  } else {
+    actions.forEach((action) => {
+      actionsWithFields.push({
+        ...action,
+        inputFields: [],
+        name: action.title || action.key
+      });
+    });
+  }
+  const typeDefinitions = generateTypeDefinitions(
+    app,
+    actionsWithFields,
+    version
+  );
+  if (output) {
+    fs__namespace.mkdirSync(path__namespace.dirname(output), { recursive: true });
+    fs__namespace.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) {
+  if (actions.length === 0) {
+    return generateEmptyTypesFile(appKey, version);
+  }
+  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: ${(/* @__PURE__ */ 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'
+
+`;
+  actions.forEach((action) => {
+    if (action.inputFields.length > 0) {
+      const inputTypeName = `${appName}${capitalize(action.action_type)}${capitalize(
+        sanitizeActionName(action.key)
+      )}Inputs`;
+      output += `interface ${inputTypeName} {
+`;
+      action.inputFields.forEach((field) => {
+        const isOptional = !field.required;
+        const fieldType = mapFieldTypeToTypeScript(field);
+        const description = field.helpText ? `  /** ${escapeComment(field.helpText)} */
+` : "";
+        output += `${description}  ${sanitizeFieldName(field.key)}${isOptional ? "?" : ""}: ${fieldType}
+`;
+      });
+      output += `}
+
+`;
+    }
+  });
+  Object.entries(actionsByType).forEach(([actionType, typeActions]) => {
+    const typeName = `${appName}${capitalize(actionType)}Actions`;
+    output += `interface ${typeName} {
+`;
+    typeActions.forEach((action) => {
+      const actionName = sanitizeActionName(action.key);
+      const description = action.description ? `  /** ${escapeComment(action.description)} */
+` : "";
+      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>
+`;
+      } else {
+        output += `${description}  ${actionName}: (options?: { inputs?: Record<string, any> } & ActionExecutionOptions) => Promise<ActionExecutionResult>
+`;
+      }
+    });
+    output += `}
+
+`;
+  });
+  output += `interface ${appName}AppProxy {
+`;
+  Object.keys(actionsByType).forEach((actionType) => {
+    const typeName = `${appName}${capitalize(actionType)}Actions`;
+    output += `  ${actionType}: ${typeName}
+`;
+  });
+  output += generateFetchMethodSignature() + "\n";
+  output += `}
+
+`;
+  output += `interface ${appName}AppFactory {
+`;
+  output += `  (options: { authenticationId: number }): ${appName}AppProxy
+`;
+  output += `}
+
+`;
+  output += `type ${appName}AppWithFactory = ${appName}AppFactory & ${appName}AppProxy
+
+`;
+  output += `export interface ${appName}Sdk {
+`;
+  output += `  apps: {
+`;
+  output += `    ${appKey}: ${appName}AppWithFactory
+`;
+  output += `  }
+`;
+  output += `}
+`;
+  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: ${(/* @__PURE__ */ 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) {
+  let sanitized = actionKey.replace(/[^a-zA-Z0-9_$]/g, "_");
+  if (/^[0-9]/.test(sanitized)) {
+    sanitized = "_" + sanitized;
+  }
+  return sanitized;
+}
+function sanitizeFieldName(fieldKey) {
+  let sanitized = fieldKey.replace(/[^a-zA-Z0-9_$]/g, "_");
+  if (/^[0-9]/.test(sanitized)) {
+    sanitized = "_" + sanitized;
+  }
+  return sanitized;
+}
+function escapeComment(comment) {
+  return comment.replace(/\*\//g, "*\\/").replace(/\r?\n/g, " ");
+}
+function mapFieldTypeToTypeScript(field) {
+  if (field.choices && field.choices.length > 0) {
+    const choiceValues = field.choices.filter(
+      (choice) => choice.value !== void 0 && choice.value !== null && choice.value !== ""
+    ).map(
+      (choice) => typeof choice.value === "string" ? `"${choice.value}"` : choice.value
+    );
+    if (choiceValues.length > 0) {
+      return choiceValues.join(" | ");
+    }
+  }
+  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:
+      return "string | number | boolean";
+  }
+}
+var BundleCodeSchema = zod.z.object({
+  input: zod.z.string().min(1).describe("Input TypeScript file path to bundle"),
+  output: zapierSdk.OutputPropertySchema.optional().describe(
+    "Output file path (defaults to input with .js extension)"
+  ),
+  string: zod.z.boolean().optional().describe("Return bundled code as string instead of writing to file"),
+  minify: zod.z.boolean().optional().describe("Minify the bundled output"),
+  target: zod.z.string().optional().describe("ECMAScript target version"),
+  cjs: zod.z.boolean().optional().describe("Output CommonJS format instead of ESM")
+}).describe("Bundle TypeScript code into executable JavaScript");
+var bundleCodePlugin = () => {
+  const bundleCodeWithSdk = zapierSdk.createFunction(async function bundleCodeWithSdk2(options) {
+    return await bundleCode(options);
+  }, BundleCodeSchema);
+  return {
+    bundleCode: bundleCodeWithSdk,
+    context: {
+      meta: {
+        bundleCode: {
+          categories: ["utility"],
+          inputSchema: BundleCodeSchema
+        }
+      }
+    }
+  };
+};
+var ZapierBundleError = class extends Error {
+  constructor(message, details, originalError) {
+    super(message);
+    this.code = "ZAPIER_BUNDLE_ERROR";
+    this.name = "ZapierBundleError";
+    this.details = details;
+    this.originalError = originalError;
+  }
+};
+async function bundleCode(options) {
+  const {
+    input,
+    output,
+    target = "es2020",
+    cjs = false,
+    minify = false,
+    string: returnString = false
+  } = options;
+  const resolvedInput = path__namespace.resolve(process.cwd(), input);
+  try {
+    const result = esbuild.buildSync({
+      entryPoints: [resolvedInput],
+      bundle: true,
+      platform: "node",
+      target,
+      format: cjs ? "cjs" : "esm",
+      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) {
+      finalOutput = JSON.stringify(bundledCode);
+    }
+    if (output) {
+      fs__namespace.mkdirSync(path__namespace.dirname(output), { recursive: true });
+      fs__namespace.writeFileSync(output, finalOutput, "utf8");
+    }
+    return finalOutput;
+  } catch (error) {
+    if (error instanceof ZapierBundleError) {
+      throw error;
+    }
+    throw new ZapierBundleError(
+      `Bundle failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+      void 0,
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+var GetConfigPathSchema = zod.z.object({}).describe("Show the path to the configuration file");
+var getConfigPathPlugin = () => {
+  const getConfigPathWithSdk = zapierSdk.createFunction(
+    async function getConfigPathWithSdk2(_options) {
+      return zapierSdkCliLogin.getConfigPath();
+    },
+    GetConfigPathSchema
+  );
+  return {
+    getConfigPath: getConfigPathWithSdk,
+    context: {
+      meta: {
+        getConfigPath: {
+          categories: ["utility"],
+          inputSchema: GetConfigPathSchema
+        }
+      }
+    }
+  };
+};
+
+// src/sdk.ts
+function createZapierCliSdk(options = {}) {
+  let sdk = zapierSdk.createZapierSdkWithoutRegistry({
+    debug: options.debug
+  });
+  sdk = sdk.addPlugin(generateTypesPlugin);
+  sdk = sdk.addPlugin(bundleCodePlugin);
+  sdk = sdk.addPlugin(getConfigPathPlugin);
+  sdk = sdk.addPlugin(mcpPlugin);
+  sdk = sdk.addPlugin(loginPlugin);
+  sdk = sdk.addPlugin(logoutPlugin);
+  const finalSdk = sdk.addPlugin(zapierSdk.registryPlugin);
+  return finalSdk;
+}
+
+exports.createZapierCliSdk = createZapierCliSdk;