@zapier/zapier-sdk-cli 0.59.0 → 0.59.2

package/dist/src/plugins/init/index.js

@@ -1,56 +0,0 @@
-import { createPluginMethod, definePlugin, } from "@zapier/zapier-sdk";
-import { InitSchema } from "./schemas";
-import { detectPackageManager } from "../../utils/package-manager-detector";
-import { validateInitOptions, withInterruptCleanup } from "./utils";
-import { getInitSteps, runStep } from "./steps";
-import { createConsoleDisplayHooks, displaySummaryAndNextSteps, } from "./display";
-import { ZapierCliExitError } from "../../utils/errors";
-import { resolveNonInteractive } from "../../utils/non-interactive";
-export { toProjectName } from "./utils";
-export const initPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
-    name: "init",
-    categories: ["utility"],
-    inputSchema: InitSchema,
-    supportsJsonOutput: false,
-    handler: async ({ options }) => {
-        const { projectName: rawName } = options;
-        const nonInteractive = resolveNonInteractive(options);
-        const cwd = process.cwd();
-        const { projectName, projectDir } = validateInitOptions({ rawName, cwd });
-        const displayHooks = createConsoleDisplayHooks();
-        const packageManagerInfo = detectPackageManager(cwd);
-        if (packageManagerInfo.name === "unknown") {
-            displayHooks.onWarn("Could not detect package manager, defaulting to npm.");
-        }
-        const packageManager = packageManagerInfo.name === "unknown" ? "npm" : packageManagerInfo.name;
-        const steps = getInitSteps({
-            projectDir,
-            projectName,
-            packageManager,
-            displayHooks,
-        });
-        const completedSetupStepIds = [];
-        for (let i = 0; i < steps.length; i++) {
-            const step = steps[i];
-            const succeeded = await withInterruptCleanup(step.cleanup, () => runStep({
-                step,
-                stepNumber: i + 1,
-                totalSteps: steps.length,
-                nonInteractive,
-                displayHooks,
-            }));
-            if (!succeeded)
-                break;
-            completedSetupStepIds.push(step.id);
-        }
-        if (completedSetupStepIds.length === 0) {
-            throw new ZapierCliExitError("Project setup failed — no steps completed.");
-        }
-        displaySummaryAndNextSteps({
-            projectName,
-            steps,
-            completedSetupStepIds,
-            packageManager,
-        });
-    },
-}));

package/dist/src/plugins/init/schemas.d.ts

@@ -1,9 +0,0 @@
-import { z } from "zod";
-export declare const TEMPLATES: readonly ["basic"];
-export type TemplateName = (typeof TEMPLATES)[number];
-export declare const InitSchema: z.ZodObject<{
-    projectName: z.ZodString;
-    nonInteractive: z.ZodOptional<z.ZodBoolean>;
-    skipPrompts: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export type InitOptions = z.infer<typeof InitSchema>;

package/dist/src/plugins/init/schemas.js

@@ -1,19 +0,0 @@
-import { z } from "zod";
-export const TEMPLATES = ["basic"];
-export const InitSchema = z
-    .object({
-    projectName: z
-        .string()
-        .min(1)
-        .describe("Name of the project directory to create"),
-    nonInteractive: z
-        .boolean()
-        .optional()
-        .describe("Skip all interactive prompts and accept all defaults"),
-    /** @deprecated Use `nonInteractive` instead. */
-    skipPrompts: z.boolean().optional().meta({
-        deprecated: true,
-        deprecationMessage: "Use --non-interactive instead.",
-    }),
-})
-    .describe("Create a new Zapier SDK project in a new directory with starter files");

package/dist/src/plugins/init/steps.d.ts

@@ -1,39 +0,0 @@
-import { type TemplateName } from "./schemas";
-import { type PackageManager } from "../../utils/package-manager-detector";
-import type { DisplayHooks, SetupStep, SetupStepId, RunnableSetupStep } from "./types";
-export type { DisplayHooks, SetupStep, SetupStepId, RunnableSetupStep };
-export declare function getTemplateDir({ template, }?: {
-    template?: TemplateName;
-}): string;
-export declare function scaffoldFiles({ projectDir, templatesDir, variables, displayHooks, }: {
-    projectDir: string;
-    templatesDir: string;
-    variables?: Record<string, unknown>;
-    displayHooks?: DisplayHooks;
-}): void;
-export declare function scaffoldProject({ projectDir, projectName, packageManager, template, displayHooks, }: {
-    projectDir: string;
-    projectName: string;
-    packageManager: PackageManager;
-    template?: TemplateName;
-    displayHooks?: DisplayHooks;
-}): void;
-export declare function runStep({ step, stepNumber, totalSteps, nonInteractive, displayHooks, }: {
-    step: RunnableSetupStep;
-    stepNumber: number;
-    totalSteps: number;
-    nonInteractive: boolean;
-    displayHooks?: DisplayHooks;
-}): Promise<boolean>;
-export declare function getInitSteps({ projectDir, projectName, packageManager, template, displayHooks, }: {
-    projectDir: string;
-    projectName: string;
-    packageManager: PackageManager;
-    template?: TemplateName;
-    displayHooks?: DisplayHooks;
-}): RunnableSetupStep[];
-export declare function buildNextSteps({ projectName, leftoverSteps, execCmd, }: {
-    projectName: string;
-    leftoverSteps: RunnableSetupStep[];
-    execCmd: string;
-}): SetupStep[];

package/dist/src/plugins/init/steps.js

@@ -1,141 +0,0 @@
-import { existsSync, mkdirSync, writeFileSync, readdirSync, copyFileSync, } from "fs";
-import { join, dirname, relative } from "path";
-import { promptYesNo, createExec, getPackageManagerCommands, getDirentParentPath, buildTemplateVariables, cleanupProject, createProjectDir, isTemplateFile, getDestRelPath, renderTemplate, } from "./utils";
-import { TEMPLATES } from "./schemas";
-import { TEMPLATES_DIR } from "../../paths";
-const DEFAULT_TEMPLATE = "basic";
-export function getTemplateDir({ template = DEFAULT_TEMPLATE, } = {}) {
-    const dirPath = join(TEMPLATES_DIR, template);
-    if (!existsSync(dirPath)) {
-        throw new Error(`Template "${template}" not found at ${dirPath}. Available templates: ${TEMPLATES.join(", ")}`);
-    }
-    return dirPath;
-}
-export function scaffoldFiles({ projectDir, templatesDir, variables = {}, displayHooks, }) {
-    const entries = readdirSync(templatesDir, {
-        withFileTypes: true,
-        recursive: true,
-    });
-    const files = entries.filter((e) => e.isFile());
-    if (files.length === 0) {
-        throw new Error(`Template directory "${templatesDir}" contains no files.`);
-    }
-    for (const entry of files) {
-        const srcPath = join(getDirentParentPath(entry), entry.name);
-        const relPath = relative(templatesDir, srcPath);
-        const isTemplate = isTemplateFile(entry.name);
-        const destRelPath = getDestRelPath(relPath, isTemplate);
-        const destPath = join(projectDir, destRelPath);
-        mkdirSync(dirname(destPath), { recursive: true });
-        if (isTemplate) {
-            writeFileSync(destPath, renderTemplate(srcPath, variables));
-        }
-        else {
-            copyFileSync(srcPath, destPath);
-        }
-        displayHooks?.onItemComplete?.(destRelPath);
-    }
-}
-export function scaffoldProject({ projectDir, projectName, packageManager, template, displayHooks, }) {
-    const variables = buildTemplateVariables({ projectName, packageManager });
-    const templatesDir = getTemplateDir({ template });
-    createProjectDir({ projectDir, projectName });
-    scaffoldFiles({ projectDir, templatesDir, variables, displayHooks });
-}
-export async function runStep({ step, stepNumber, totalSteps, nonInteractive, displayHooks, }) {
-    if (step.askConfirmation) {
-        const should = await promptYesNo({
-            message: step.description,
-            defaultValue: true,
-            nonInteractive,
-        });
-        if (!should)
-            return false;
-    }
-    displayHooks?.onStepStart({
-        description: step.description,
-        stepNumber,
-        totalSteps,
-        command: step.command,
-        nonInteractive,
-    });
-    try {
-        await step.run();
-        displayHooks?.onStepSuccess({ stepNumber, totalSteps });
-        return true;
-    }
-    catch (err) {
-        step.cleanup?.();
-        displayHooks?.onStepError({
-            description: step.description,
-            command: step.command,
-            err,
-        });
-        return false;
-    }
-}
-export function getInitSteps({ projectDir, projectName, packageManager, template, displayHooks, }) {
-    if (template !== undefined &&
-        !TEMPLATES.includes(template)) {
-        throw new Error(`Unknown template "${template}". Available templates: ${TEMPLATES.join(", ")}`);
-    }
-    const { installCmd, execCmd, devCmd } = getPackageManagerCommands({
-        packageManager,
-    });
-    const exec = createExec({ cwd: projectDir });
-    return [
-        {
-            id: "scaffold",
-            description: "Scaffold project files",
-            cleanup: () => cleanupProject({ projectDir }),
-            run: () => scaffoldProject({
-                projectDir,
-                projectName,
-                packageManager,
-                template,
-                displayHooks,
-            }),
-        },
-        {
-            id: "install-deps",
-            description: "Install dependencies",
-            askConfirmation: true,
-            command: installCmd,
-            run: () => exec(installCmd),
-        },
-        {
-            id: "login",
-            description: "Log in to Zapier",
-            askConfirmation: true,
-            command: `${execCmd} zapier-sdk login`,
-            run: () => exec(`${execCmd} zapier-sdk login`),
-        },
-        {
-            id: "run",
-            description: "Run your app",
-            askConfirmation: true,
-            command: devCmd,
-            run: () => exec(devCmd),
-        },
-    ];
-}
-export function buildNextSteps({ projectName, leftoverSteps, execCmd, }) {
-    return [
-        {
-            description: "Change into your project directory",
-            command: `cd ${projectName}`,
-        },
-        ...leftoverSteps.map(({ description, command }) => ({
-            description,
-            command,
-        })),
-        {
-            description: "Search for an app to integrate",
-            command: `${execCmd} zapier-sdk list-apps --search "<app name>"`,
-        },
-        {
-            description: "Add an app and generate TypeScript types",
-            command: `${execCmd} zapier-sdk add <app-key>`,
-        },
-    ];
-}

package/dist/src/plugins/init/types.d.ts

@@ -1,31 +0,0 @@
-export interface DisplayHooks {
-    onItemComplete: (message: string) => void;
-    onWarn: (message: string) => void;
-    onStepStart: (params: {
-        description: string;
-        stepNumber: number;
-        totalSteps: number;
-        command?: string;
-        nonInteractive: boolean;
-    }) => void;
-    onStepSuccess: (params: {
-        stepNumber: number;
-        totalSteps: number;
-    }) => void;
-    onStepError: (params: {
-        description: string;
-        command?: string;
-        err: unknown;
-    }) => void;
-}
-export interface SetupStep {
-    description: string;
-    command?: string;
-}
-export type SetupStepId = "scaffold" | "install-deps" | "login" | "run";
-export interface RunnableSetupStep extends SetupStep {
-    id: SetupStepId;
-    askConfirmation?: boolean;
-    cleanup?: () => void;
-    run: () => void | Promise<void>;
-}

package/dist/src/plugins/init/types.js

@@ -1 +0,0 @@
-export {};

package/dist/src/plugins/init/utils.d.ts

@@ -1,48 +0,0 @@
-import type { Dirent } from "fs";
-import { type PackageManager } from "../../utils/package-manager-detector";
-export declare function getDirentParentPath(entry: Dirent): string;
-export declare function toProjectName(name: string): string;
-export declare function validateInitOptions({ rawName, cwd, }: {
-    rawName: string;
-    cwd: string;
-}): {
-    projectName: string;
-    projectDir: string;
-};
-export declare function createExec({ cwd }: {
-    cwd: string;
-}): (cmd: string) => void;
-export declare function promptYesNo({ message, defaultValue, nonInteractive, }: {
-    message: string;
-    defaultValue: boolean;
-    nonInteractive: boolean;
-}): Promise<boolean>;
-export declare function getPackageManagerCommands({ packageManager, }: {
-    packageManager: PackageManager;
-}): {
-    installCmd: string;
-    devCmd: string;
-    devScript: string;
-    execCmd: string;
-};
-export declare function isTemplateFile(name: string): boolean;
-export declare function getDestRelPath(relPath: string, isTemplate: boolean): string;
-export declare function renderTemplate(srcPath: string, variables: Record<string, unknown>): string;
-export declare function buildTemplateVariables({ projectName, packageManager, }: {
-    projectName: string;
-    packageManager: PackageManager;
-}): Record<string, unknown>;
-export declare function cleanupProject({ projectDir }: {
-    projectDir: string;
-}): void;
-/**
- * Registers a cleanup callback that fires if the process receives SIGINT while
- * `fn` is running. The listener is always removed once `fn` settles, preventing
- * listener leaks across steps. The SIGINT is re-raised after cleanup so the
- * shell receives a proper signal-terminated exit code (130) rather than exit(1).
- */
-export declare function withInterruptCleanup(cleanup: (() => void) | undefined, fn: () => Promise<boolean>): Promise<boolean>;
-export declare function createProjectDir({ projectDir, projectName, }: {
-    projectDir: string;
-    projectName: string;
-}): void;

package/dist/src/plugins/init/utils.js

@@ -1,135 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync } from "fs";
-import { execSync } from "child_process";
-import { extname, join } from "path";
-import chalk from "chalk";
-import Handlebars from "handlebars";
-import inquirer from "inquirer";
-// Node 20 added `parentPath`; Node 18 used `path` for the same purpose.
-export function getDirentParentPath(entry) {
-    const e = entry;
-    const parent = e.parentPath ?? e.path;
-    if (!parent)
-        throw new Error("readdirSync entry missing parentPath/path — unsupported Node version");
-    return parent;
-}
-export function toProjectName(name) {
-    // Essentially converts to kebab-case
-    return (name
-        .toLowerCase()
-        // Replace anything that isn't a letter, digit, or hyphen with a hyphen.
-        // Hyphens are kept as-is since they're valid in npm package names.
-        .replace(/[^a-z0-9-]/g, "-")
-        .replace(/-+/g, "-") // collapse consecutive hyphens produced by the step above
-        .replace(/^-|-$/g, "")); // strip any leading/trailing hyphens
-}
-export function validateInitOptions({ rawName, cwd, }) {
-    const projectName = toProjectName(rawName);
-    if (!projectName) {
-        throw new Error(`"${rawName}" results in an empty project name. Provide a name with at least one letter or number.`);
-    }
-    const projectDir = join(cwd, projectName);
-    if (existsSync(projectDir)) {
-        const contents = readdirSync(projectDir);
-        if (contents.length > 0) {
-            throw new Error(`Directory "${projectName}" already exists and is not empty. Choose a different name.`);
-        }
-    }
-    return { projectName, projectDir };
-}
-// shell is required on Windows where npx/npm/pnpm/yarn are .cmd files
-// that execSync cannot locate without a shell.
-export function createExec({ cwd }) {
-    return (cmd) => execSync(cmd, {
-        cwd,
-        stdio: "inherit",
-        shell: process.platform === "win32" ? "cmd.exe" : "/bin/sh",
-    });
-}
-export async function promptYesNo({ message, defaultValue, nonInteractive, }) {
-    if (nonInteractive)
-        return defaultValue;
-    const { answer } = await inquirer.prompt([
-        { type: "confirm", name: "answer", message, default: defaultValue },
-    ]);
-    return answer;
-}
-export function getPackageManagerCommands({ packageManager, }) {
-    return {
-        installCmd: `${packageManager} install`,
-        devCmd: packageManager === "yarn" ? "yarn dev" : `${packageManager} run dev`,
-        devScript: packageManager === "bun" ? "bun src/index.ts" : "tsx src/index.ts",
-        execCmd: {
-            npm: "npx",
-            yarn: "yarn dlx",
-            pnpm: "pnpm dlx",
-            bun: "bunx",
-        }[packageManager],
-    };
-}
-export function isTemplateFile(name) {
-    return extname(name) === ".hbs";
-}
-export function getDestRelPath(relPath, isTemplate) {
-    return isTemplate ? relPath.slice(0, -extname(relPath).length) : relPath;
-}
-export function renderTemplate(srcPath, variables) {
-    const source = readFileSync(srcPath, "utf-8");
-    // Without this, Handlebars HTML-encodes output (& → &), which corrupts JSON and TypeScript files.
-    const template = Handlebars.compile(source, { noEscape: true });
-    return template(variables);
-}
-export function buildTemplateVariables({ projectName, packageManager, }) {
-    const { execCmd, devScript, devCmd } = getPackageManagerCommands({
-        packageManager,
-    });
-    return {
-        projectName,
-        execCmd,
-        devScript,
-        devCmd,
-        includeTsx: packageManager !== "bun",
-    };
-}
-export function cleanupProject({ projectDir }) {
-    console.log("\n" + chalk.yellow("!") + "  Cleaning up...");
-    rmSync(projectDir, { recursive: true, force: true });
-}
-/**
- * Registers a cleanup callback that fires if the process receives SIGINT while
- * `fn` is running. The listener is always removed once `fn` settles, preventing
- * listener leaks across steps. The SIGINT is re-raised after cleanup so the
- * shell receives a proper signal-terminated exit code (130) rather than exit(1).
- */
-export async function withInterruptCleanup(cleanup, fn) {
-    if (!cleanup)
-        return fn();
-    const handler = () => {
-        cleanup();
-        process.removeListener("SIGINT", handler);
-        process.kill(process.pid, "SIGINT");
-    };
-    process.on("SIGINT", handler);
-    try {
-        return await fn();
-    }
-    finally {
-        process.removeListener("SIGINT", handler);
-    }
-}
-export function createProjectDir({ projectDir, projectName, }) {
-    try {
-        mkdirSync(projectDir, { recursive: true });
-    }
-    catch (err) {
-        if (err instanceof Error) {
-            const code = err.code;
-            if (code === "EACCES") {
-                throw new Error(`Permission denied creating "${projectName}". Check directory permissions.`);
-            }
-            if (code === "ENOSPC") {
-                throw new Error("No space left on device.");
-            }
-        }
-        throw err;
-    }
-}

package/dist/src/plugins/login/index.d.ts

@@ -1,25 +0,0 @@
-import { type AccountAuthCliContext } from "../../utils/auth/account-auth";
-export declare const loginPlugin: (sdk: {
-    context: import("@zapier/zapier-sdk").EventEmissionContext;
-} & {
-    context: AccountAuthCliContext;
-} & {
-    context: {
-        meta: Record<string, import("@zapier/zapier-sdk").PluginMeta>;
-    };
-}) => {
-    login: (options?: {
-        name?: string | undefined;
-        timeout?: string | undefined;
-        useApprovals?: boolean | undefined;
-        nonInteractive?: boolean | undefined;
-        skipPrompts?: boolean | undefined;
-    } | undefined) => Promise<void>;
-} & {
-    context: {
-        meta: {
-            login: import("@zapier/zapier-sdk").PluginMeta<unknown>;
-        };
-    };
-};
-export type LoginPluginProvides = ReturnType<typeof loginPlugin>;

package/dist/src/plugins/login/index.js

@@ -1,12 +0,0 @@
-import { createPluginMethod, definePlugin, } from "@zapier/zapier-sdk";
-import { runAccountAuth, } from "../../utils/auth/account-auth";
-import { LoginSchema } from "./schemas";
-export const loginPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
-    name: "login",
-    categories: ["account"],
-    inputSchema: LoginSchema,
-    supportsJsonOutput: false,
-    handler: async ({ sdk, options }) => {
-        await runAccountAuth({ sdk, options, entryPoint: "login" });
-    },
-}));

package/dist/src/plugins/login/schemas.d.ts

@@ -1,9 +0,0 @@
-import { z } from "zod";
-export declare const LoginSchema: z.ZodObject<{
-    name: z.ZodOptional<z.ZodString>;
-    timeout: z.ZodOptional<z.ZodString>;
-    useApprovals: z.ZodOptional<z.ZodBoolean>;
-    nonInteractive: z.ZodOptional<z.ZodBoolean>;
-    skipPrompts: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export type LoginOptions = z.infer<typeof LoginSchema>;

package/dist/src/plugins/login/schemas.js

@@ -1,27 +0,0 @@
-import { z } from "zod";
-// Login schema
-export const LoginSchema = z
-    .object({
-    name: z
-        .string()
-        .optional()
-        .describe("Name to identify these credentials (defaults to <email>@<hostname>). Provide this to set a custom name without the interactive prompt."),
-    timeout: z
-        .string()
-        .optional()
-        .describe("Login timeout in seconds (default: 300)"),
-    useApprovals: z
-        .boolean()
-        .optional()
-        .describe("Require approvals for actions performed with these credentials"),
-    nonInteractive: z
-        .boolean()
-        .optional()
-        .describe("Skip interactive prompts. Uses defaults where possible; errors instead of prompting when input is required. Useful in CI, piped output, or environments where TTY detection is unreliable."),
-    /** @deprecated Use `nonInteractive` instead. */
-    skipPrompts: z.boolean().optional().meta({
-        deprecated: true,
-        deprecationMessage: "Use --non-interactive instead.",
-    }),
-})
-    .describe("Log in to Zapier to access your account");

package/dist/src/plugins/logout/index.d.ts

@@ -1,30 +0,0 @@
-import { type ApiClient, type ResolvedCredentials } from "@zapier/zapier-sdk";
-import { type LogoutEventEmitter } from "../../login/credentials-revoke";
-interface CliContext {
-    api: ApiClient;
-    resolveCredentials?: () => Promise<ResolvedCredentials | undefined>;
-    options?: {
-        onEvent?: LogoutEventEmitter;
-        baseUrl?: string;
-        credentials?: unknown;
-    };
-}
-export declare const logoutPlugin: (sdk: {
-    context: import("@zapier/zapier-sdk").EventEmissionContext;
-} & {
-    context: CliContext;
-} & {
-    context: {
-        meta: Record<string, import("@zapier/zapier-sdk").PluginMeta>;
-    };
-}) => {
-    logout: (options?: Record<string, never> | undefined) => Promise<void>;
-} & {
-    context: {
-        meta: {
-            logout: import("@zapier/zapier-sdk").PluginMeta<unknown>;
-        };
-    };
-};
-export type LogoutPluginProvides = ReturnType<typeof logoutPlugin>;
-export {};

package/dist/src/plugins/logout/index.js

@@ -1,33 +0,0 @@
-import { createPluginMethod, definePlugin, } from "@zapier/zapier-sdk";
-import { logout as jwtLogout } from "../../login";
-import { getActiveCredentials } from "../../login/credentials-store";
-import { revokeCredentials, } from "../../login/credentials-revoke";
-import { resolveCredentialsBaseUrl } from "../auth/credentials-base-url";
-import { LogoutSchema } from "./schemas";
-export const logoutPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
-    name: "logout",
-    categories: ["account"],
-    inputSchema: LogoutSchema,
-    supportsJsonOutput: false,
-    handler: async ({ sdk }) => {
-        const credentialsBaseUrl = await resolveCredentialsBaseUrl(sdk.context);
-        const activeCredentials = getActiveCredentials({
-            baseUrl: credentialsBaseUrl,
-        });
-        const onEvent = sdk.context.options?.onEvent;
-        if (!activeCredentials) {
-            await jwtLogout({ onEvent });
-            console.log("✅ Successfully logged out");
-            return;
-        }
-        // Logout is teardown: clear local state even if the server refuses to
-        // revoke the credential, so a permanent 4xx can't strand the user.
-        await revokeCredentials({
-            api: sdk.context.api,
-            credentials: activeCredentials,
-            onEvent,
-            alwaysClearLocalState: true,
-        });
-        console.log("✅ Successfully logged out");
-    },
-}));

package/dist/src/plugins/logout/schemas.d.ts

@@ -1,2 +0,0 @@
-import { z } from "zod";
-export declare const LogoutSchema: z.ZodObject<{}, z.core.$strip>;

package/dist/src/plugins/logout/schemas.js

@@ -1,4 +0,0 @@
-import { z } from "zod";
-export const LogoutSchema = z
-    .object({})
-    .describe("Log out of your Zapier account");

package/dist/src/plugins/mcp/index.d.ts

@@ -1,28 +0,0 @@
-import { type Plugin, type PluginProvides } from "@zapier/zapier-sdk";
-export declare const mcpPlugin: (sdk: {
-    context: {
-        options?: {
-            debug?: boolean;
-            maxConcurrentRequests?: number;
-        };
-        extensions?: Plugin<unknown, PluginProvides>[];
-        experimental?: boolean;
-    };
-} & {
-    context: import("@zapier/zapier-sdk").EventEmissionContext;
-} & {
-    context: {
-        meta: Record<string, import("@zapier/zapier-sdk").PluginMeta>;
-    };
-}) => {
-    mcp: (options?: {
-        port?: string | undefined;
-    } | undefined) => Promise<void>;
-} & {
-    context: {
-        meta: {
-            mcp: import("@zapier/zapier-sdk").PluginMeta<unknown>;
-        };
-    };
-};
-export type McpPluginProvides = ReturnType<typeof mcpPlugin>;