@zapier/zapier-sdk-cli 0.16.1 → 0.16.4

package/src/plugins/generateAppTypes/index.ts

@@ -1,227 +0,0 @@
-import type {
-  Plugin,
-  GetSdkType,
-  ListActionsPluginProvides,
-  ListAppsPluginProvides,
-  ListInputFieldsPluginProvides,
-  ListAuthenticationsPluginProvides,
-  ManifestPluginProvides,
-  AppItem,
-} from "@zapier/zapier-sdk";
-import {
-  createFunction,
-  ZapierValidationError,
-  ZapierUnknownError,
-} from "@zapier/zapier-sdk";
-import {
-  GenerateAppTypesSchema,
-  type GenerateAppTypesOptions,
-  type GenerateAppTypesResult,
-} from "./schemas";
-import { AstTypeGenerator } from "../../generators/ast-generator";
-import { getManifestKey } from "../../utils/manifest-helpers";
-import { mkdir, writeFile } from "fs/promises";
-import { join, resolve } from "path";
-import { detectTypesOutputDirectory } from "../../utils/directory-detection";
-
-export interface GenerateAppTypesPluginProvides {
-  generateAppTypes: (
-    options: GenerateAppTypesOptions,
-  ) => Promise<GenerateAppTypesResult>;
-  context: {
-    meta: {
-      generateAppTypes: {
-        inputSchema: typeof GenerateAppTypesSchema;
-      };
-    };
-  };
-}
-
-export const generateAppTypesPlugin: Plugin<
-  GetSdkType<
-    ListAppsPluginProvides &
-      ListActionsPluginProvides &
-      ListInputFieldsPluginProvides &
-      ListAuthenticationsPluginProvides &
-      ManifestPluginProvides
-  >,
-  {},
-  GenerateAppTypesPluginProvides
-> = ({ sdk }) => {
-  const generateAppTypes = createFunction(async function generateAppTypes(
-    options: GenerateAppTypesOptions,
-  ): Promise<GenerateAppTypesResult> {
-    const {
-      appKeys,
-      authenticationIds,
-      skipWrite = false,
-      typesOutputDirectory = await detectTypesOutputDirectory(),
-      onProgress,
-    } = options;
-
-    const resolvedTypesOutput = resolve(typesOutputDirectory);
-
-    const result: GenerateAppTypesResult = {
-      typeDefinitions: {},
-    };
-
-    // Get apps using listApps (which respects existing manifest for version locking)
-    onProgress?.({ type: "apps_lookup_start", count: appKeys.length });
-    const appsIterator = sdk.listApps({ appKeys }).items();
-    const apps: AppItem[] = [];
-    for await (const app of appsIterator) {
-      apps.push(app);
-      onProgress?.({ type: "app_found", app });
-    }
-    onProgress?.({ type: "apps_lookup_complete", count: apps.length });
-
-    if (apps.length === 0) {
-      return result;
-    }
-
-    // Fetch authentications if provided
-    const authentications = [];
-    if (authenticationIds && authenticationIds.length > 0) {
-      onProgress?.({
-        type: "authentications_lookup_start",
-        count: authenticationIds.length,
-      });
-      const authsIterator = sdk
-        .listAuthentications({ authenticationIds })
-        .items();
-      for await (const auth of authsIterator) {
-        authentications.push(auth);
-      }
-      onProgress?.({
-        type: "authentications_lookup_complete",
-        count: authentications.length,
-      });
-    }
-
-    // Ensure output directory exists if we're writing files
-    if (!skipWrite && resolvedTypesOutput) {
-      await mkdir(resolvedTypesOutput, { recursive: true });
-    }
-
-    // Initialize writtenFiles if we're writing to disk
-    if (!skipWrite) {
-      result.writtenFiles = {};
-    }
-
-    // Process each app
-    for (const app of apps) {
-      onProgress?.({
-        type: "app_processing_start",
-        appKey: app.key,
-        slug: app.slug,
-      });
-
-      try {
-        if (!app.version) {
-          const errorMessage = `Invalid implementation ID format: ${app.implementation_id}. Expected format: <implementationName>@<version>`;
-          onProgress?.({
-            type: "app_processing_error",
-            appKey: app.key,
-            error: errorMessage,
-          });
-          throw new ZapierValidationError(errorMessage, {
-            details: {
-              appKey: app.key,
-              implementationId: app.implementation_id,
-            },
-          });
-        }
-
-        // Find matching authentication for this app if authentications were provided
-        let authenticationId: number | undefined;
-        if (authentications.length > 0) {
-          const matchingAuth = authentications.find((auth) => {
-            return auth.app_key === app.key;
-          });
-
-          if (matchingAuth) {
-            authenticationId = matchingAuth.id;
-            onProgress?.({
-              type: "authentication_matched",
-              appKey: app.key,
-              authenticationId: matchingAuth.id,
-              authenticationTitle: matchingAuth.title || "",
-            });
-          } else {
-            onProgress?.({
-              type: "authentication_not_matched",
-              appKey: app.key,
-            });
-          }
-        }
-
-        const manifestKey = getManifestKey(app);
-
-        // Generate type definitions
-        const generator = new AstTypeGenerator();
-        const typeDefinitionString = await generator.generateTypes({
-          app,
-          authenticationId,
-          sdk,
-        });
-
-        result.typeDefinitions[manifestKey] = typeDefinitionString;
-
-        onProgress?.({
-          type: "type_generated",
-          manifestKey,
-          sizeBytes: typeDefinitionString.length,
-        });
-
-        // Write to file if skipWrite is false
-        if (!skipWrite && resolvedTypesOutput && result.writtenFiles) {
-          const filePath = join(resolvedTypesOutput, `${manifestKey}.d.ts`);
-          await writeFile(filePath, typeDefinitionString, "utf8");
-
-          result.writtenFiles[manifestKey] = filePath;
-
-          onProgress?.({
-            type: "file_written",
-            manifestKey,
-            filePath,
-          });
-        }
-
-        onProgress?.({
-          type: "app_processing_complete",
-          appKey: app.key,
-        });
-      } catch (error) {
-        const errorMessage = `Failed to process app ${app.key}: ${error instanceof Error ? error.message : String(error)}`;
-
-        onProgress?.({
-          type: "app_processing_error",
-          appKey: app.key,
-          error: errorMessage,
-        });
-
-        if (error instanceof ZapierValidationError) {
-          throw error; // Preserve the specific error type
-        } else {
-          throw new ZapierUnknownError(errorMessage, {
-            cause: error, // Works for both Error and non-Error
-          });
-        }
-      }
-    }
-
-    return result;
-  }, GenerateAppTypesSchema);
-
-  return {
-    generateAppTypes,
-    context: {
-      meta: {
-        generateAppTypes: {
-          categories: ["utility"],
-          inputSchema: GenerateAppTypesSchema,
-        },
-      },
-    },
-  };
-};

package/src/plugins/generateAppTypes/schemas.ts

@@ -1,61 +0,0 @@
-import { z } from "zod";
-import type { AppItem } from "@zapier/zapier-sdk";
-
-export const GenerateAppTypesSchema = z
-  .object({
-    appKeys: z
-      .array(z.string().min(1, "App key cannot be empty"))
-      .min(1, "At least one app key is required")
-      .describe(
-        "One or more app keys to generate types for (e.g., 'slack', 'github', 'trello')",
-      ),
-    authenticationIds: z
-      .array(z.string())
-      .optional()
-      .describe(
-        "Authentication IDs to use for type generation (e.g., ['123', '456'])",
-      ),
-    skipWrite: z
-      .boolean()
-      .optional()
-      .describe(
-        "If true, returns type definitions without writing to disk. If false or omitted, writes type files.",
-      ),
-    typesOutputDirectory: z
-      .string()
-      .optional()
-      .describe(
-        "Directory for TypeScript type files. Required when skipWrite is false or omitted.",
-      ),
-  })
-  .describe(
-    "Generate TypeScript type definitions for apps - can optionally write to disk or just return type strings",
-  );
-
-export type GenerateAppTypesOptions = z.infer<typeof GenerateAppTypesSchema> & {
-  onProgress?: (event: AppTypesProgressEvent) => void;
-};
-
-export type AppTypesProgressEvent =
-  | { type: "apps_lookup_start"; count: number }
-  | { type: "app_found"; app: AppItem }
-  | { type: "apps_lookup_complete"; count: number }
-  | { type: "authentications_lookup_start"; count: number }
-  | { type: "authentications_lookup_complete"; count: number }
-  | { type: "app_processing_start"; appKey: string; slug?: string }
-  | {
-      type: "authentication_matched";
-      appKey: string;
-      authenticationId: number;
-      authenticationTitle: string;
-    }
-  | { type: "authentication_not_matched"; appKey: string }
-  | { type: "type_generated"; manifestKey: string; sizeBytes: number }
-  | { type: "file_written"; manifestKey: string; filePath: string }
-  | { type: "app_processing_complete"; appKey: string }
-  | { type: "app_processing_error"; appKey: string; error: string };
-
-export interface GenerateAppTypesResult {
-  typeDefinitions: Record<string, string>; // manifestKey -> type definition string
-  writtenFiles?: Record<string, string>; // manifestKey -> file path (only when skipWrite is false)
-}

package/src/plugins/getLoginConfigPath/index.ts

@@ -1,45 +0,0 @@
-import type { Plugin } from "@zapier/zapier-sdk";
-import {
-  GetLoginConfigPathSchema,
-  type GetLoginConfigPathOptions,
-} from "./schemas";
-import { createFunction } from "@zapier/zapier-sdk";
-import { getConfigPath } from "@zapier/zapier-sdk-cli-login";
-
-export interface GetLoginConfigPathPluginProvides {
-  getLoginConfigPath: (options?: GetLoginConfigPathOptions) => Promise<string>;
-  context: {
-    meta: {
-      getLoginConfigPath: {
-        inputSchema: typeof GetLoginConfigPathSchema;
-      };
-    };
-  };
-}
-
-export const getLoginConfigPathPlugin: Plugin<
-  {}, // requires no existing SDK methods
-  {}, // requires no context
-  GetLoginConfigPathPluginProvides
-> = () => {
-  const getLoginConfigPathWithSdk = createFunction(
-    async function getLoginConfigPathWithSdk(
-      _options?: GetLoginConfigPathOptions,
-    ): Promise<string> {
-      return getConfigPath();
-    },
-    GetLoginConfigPathSchema,
-  );
-
-  return {
-    getLoginConfigPath: getLoginConfigPathWithSdk,
-    context: {
-      meta: {
-        getLoginConfigPath: {
-          categories: ["utility"],
-          inputSchema: GetLoginConfigPathSchema,
-        },
-      },
-    },
-  };
-};

package/src/plugins/getLoginConfigPath/schemas.ts

@@ -1,10 +0,0 @@
-import { z } from "zod";
-
-// Get login config path schema - simple command with no parameters
-export const GetLoginConfigPathSchema = z
-  .object({})
-  .describe("Show the path to the login configuration file");
-
-export type GetLoginConfigPathOptions = z.infer<
-  typeof GetLoginConfigPathSchema
->;

package/src/plugins/index.ts

@@ -1,8 +0,0 @@
-export { loginPlugin } from "./login";
-export { logoutPlugin } from "./logout";
-export { mcpPlugin } from "./mcp";
-export { bundleCodePlugin } from "./bundleCode";
-export { getLoginConfigPathPlugin } from "./getLoginConfigPath";
-export { addPlugin } from "./add";
-export { generateAppTypesPlugin } from "./generateAppTypes";
-export { buildManifestPlugin } from "./buildManifest";

package/src/plugins/login/index.ts

@@ -1,135 +0,0 @@
-import { createFunction } from "@zapier/zapier-sdk";
-import type { Plugin } from "@zapier/zapier-sdk";
-import type { EventEmissionContext } from "@zapier/zapier-sdk";
-import login from "../../utils/auth/login";
-import { getLoggedInUser } from "@zapier/zapier-sdk-cli-login";
-import { LoginSchema, type LoginOptions } from "./schemas";
-import { buildCliCommandExecutedEvent } from "../../telemetry/builders";
-import cliPackageJson from "../../../package.json";
-
-interface CliContext {
-  session_id?: string | null;
-  selected_api?: string | null;
-  app_id?: number | null;
-  app_version_id?: number | null;
-}
-
-interface LoginPluginProvides {
-  login: (options: LoginOptions) => Promise<void>;
-  context: {
-    meta: {
-      login: {
-        inputSchema: typeof LoginSchema;
-        categories: string[];
-      };
-    };
-  };
-}
-
-const CLI_COMMAND_EXECUTED_EVENT_SUBJECT =
-  "platform.sdk.CliCommandExecutedEvent";
-
-// Internal type for loginWithSdk that includes SDK URL options
-interface LoginWithSdkOptions extends LoginOptions {
-  baseUrl?: string;
-  authBaseUrl?: string;
-  authClientId?: string;
-}
-
-const loginWithSdk = createFunction(
-  async (options: LoginWithSdkOptions): Promise<void> => {
-    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({
-      timeoutMs: timeoutSeconds * 1000,
-      baseUrl: options.baseUrl,
-      authBaseUrl: options.authBaseUrl,
-      authClientId: options.authClientId,
-    });
-    const user = await getLoggedInUser();
-
-    console.log(`✅ Successfully logged in as ${user.email}`);
-  },
-);
-
-export const loginPlugin: Plugin<
-  {},
-  EventEmissionContext & CliContext,
-  LoginPluginProvides
-> = ({ context }) => {
-  // Wrap the login function to emit telemetry events
-  const loginWithTelemetry = async (options: LoginOptions): Promise<void> => {
-    const startTime = Date.now();
-    let success = false;
-    let errorMessage: string | null = null;
-    let accountId: number | null = null;
-    let customUserId: number | null = null;
-
-    try {
-      await loginWithSdk({
-        ...options,
-        baseUrl: context.options?.baseUrl,
-        authBaseUrl: context.options?.authBaseUrl,
-        authClientId: context.options?.authClientId,
-      });
-      success = true;
-
-      // Extract user IDs after successful login
-      try {
-        ({ accountId, customUserId } = await getLoggedInUser());
-      } catch {
-        // If we can't get user info, continue without it
-      }
-    } catch (error) {
-      success = false;
-      errorMessage = error instanceof Error ? error.message : "Login failed";
-      throw error;
-    } finally {
-      // Emit CLI command executed event if event emission is available
-      const event = buildCliCommandExecutedEvent({
-        data: {
-          cli_primary_command: "login",
-          success_flag: success,
-          execution_duration_ms: Date.now() - startTime,
-          exit_code: success ? 0 : 1,
-          error_message: errorMessage,
-          command_category: "authentication",
-          requires_auth: false,
-          cli_arguments: [
-            "login",
-            options.timeout ? `--timeout=${options.timeout}` : null,
-          ].filter(Boolean) as string[],
-        },
-        context: {
-          session_id: context.session_id,
-          selected_api: context.selected_api,
-          app_id: context.app_id,
-          app_version_id: context.app_version_id,
-          customuser_id: customUserId,
-          account_id: accountId,
-        },
-        cliVersion: cliPackageJson.version,
-      });
-      context.eventEmission.emit(CLI_COMMAND_EXECUTED_EVENT_SUBJECT, event);
-    }
-  };
-
-  return {
-    login: loginWithTelemetry,
-    context: {
-      meta: {
-        login: {
-          categories: ["account"],
-          inputSchema: LoginSchema,
-        },
-      },
-    },
-  };
-};
-
-export type { LoginPluginProvides };

package/src/plugins/login/schemas.ts

@@ -1,13 +0,0 @@
-import { z } from "zod";
-
-// Login schema
-export const LoginSchema = z
-  .object({
-    timeout: z
-      .string()
-      .optional()
-      .describe("Login timeout in seconds (default: 300)"),
-  })
-  .describe("Log in to Zapier to access your account");
-
-export type LoginOptions = z.infer<typeof LoginSchema>;

package/src/plugins/logout/index.ts

@@ -1,37 +0,0 @@
-import { createFunction } from "@zapier/zapier-sdk";
-import type { Plugin } from "@zapier/zapier-sdk";
-import { logout } from "@zapier/zapier-sdk-cli-login";
-import { LogoutSchema, type LogoutOptions } from "./schemas";
-
-interface LogoutPluginProvides {
-  logout: (options: LogoutOptions) => Promise<void>;
-  context: {
-    meta: {
-      logout: {
-        inputSchema: typeof LogoutSchema;
-        categories: string[];
-      };
-    };
-  };
-}
-
-const logoutWithSdk = createFunction(async function logoutWithSdk(
-  _options: LogoutOptions,
-): Promise<void> {
-  logout();
-  console.log("✅ Successfully logged out");
-}, LogoutSchema);
-
-export const logoutPlugin: Plugin<{}, {}, LogoutPluginProvides> = () => ({
-  logout: logoutWithSdk,
-  context: {
-    meta: {
-      logout: {
-        categories: ["account"],
-        inputSchema: LogoutSchema,
-      },
-    },
-  },
-});
-
-export type { LogoutPluginProvides };

package/src/plugins/logout/schemas.ts

@@ -1,8 +0,0 @@
-import { z } from "zod";
-
-// Logout schema (no parameters needed)
-export const LogoutSchema = z
-  .object({})
-  .describe("Log out of your Zapier account");
-
-export type LogoutOptions = z.infer<typeof LogoutSchema>;

package/src/plugins/mcp/index.ts

@@ -1,43 +0,0 @@
-import { createFunction } from "@zapier/zapier-sdk";
-import type { Plugin } from "@zapier/zapier-sdk";
-import { startMcpServer } from "@zapier/zapier-sdk-mcp";
-import { McpSchema, type McpOptions } from "./schemas";
-
-interface McpPluginProvides {
-  mcp: (options: McpOptions) => Promise<void>;
-  context: {
-    meta: {
-      mcp: {
-        inputSchema: typeof McpSchema;
-        categories: string[];
-      };
-    };
-  };
-}
-
-export const mcpPlugin: Plugin<{}, {}, McpPluginProvides> = ({ context }) => {
-  const mcpWithSdk = createFunction(async function mcpWithSdk(
-    options: McpOptions,
-  ): Promise<void> {
-    // Pass through the SDK's debug option to the MCP server
-    const mcpOptions = {
-      ...options,
-      debug: context.options.debug,
-    };
-    return await startMcpServer(mcpOptions);
-  }, McpSchema);
-
-  return {
-    mcp: mcpWithSdk,
-    context: {
-      meta: {
-        mcp: {
-          categories: ["utility"],
-          inputSchema: McpSchema,
-        },
-      },
-    },
-  };
-};
-
-export type { McpPluginProvides };

package/src/plugins/mcp/schemas.ts

@@ -1,13 +0,0 @@
-import { z } from "zod";
-
-// MCP server schema
-export const McpSchema = z
-  .object({
-    port: z
-      .string()
-      .optional()
-      .describe("Port to listen on (for future HTTP transport)"),
-  })
-  .describe("Start MCP server for Zapier SDK");
-
-export type McpOptions = z.infer<typeof McpSchema>;

package/src/sdk.ts

@@ -1,45 +0,0 @@
-import {
-  createZapierSdkWithoutRegistry,
-  registryPlugin,
-  type ZapierSdkOptions,
-} from "@zapier/zapier-sdk";
-import {
-  loginPlugin,
-  logoutPlugin,
-  mcpPlugin,
-  bundleCodePlugin,
-  getLoginConfigPathPlugin,
-  addPlugin,
-  generateAppTypesPlugin,
-  buildManifestPlugin,
-} from "./plugins/index";
-import type { ZapierSdkCli } from "./types/sdk";
-
-export interface ZapierCliSdkOptions extends ZapierSdkOptions {}
-
-/**
- * Create a Zapier SDK instance configured specifically for the CLI
- * Includes all CLI-specific plugins in addition to the standard SDK functionality
- */
-export function createZapierCliSdk(
-  options: ZapierCliSdkOptions = {},
-): ZapierSdkCli {
-  // Create SDK instance and chain all plugins
-  // Chaining prevents type widening that occurs with let reassignment
-  return (
-    createZapierSdkWithoutRegistry({
-      ...options,
-    })
-      // Add CLI-specific plugins before registry
-      .addPlugin(generateAppTypesPlugin)
-      .addPlugin(buildManifestPlugin)
-      .addPlugin(bundleCodePlugin)
-      .addPlugin(getLoginConfigPathPlugin)
-      .addPlugin(addPlugin)
-      .addPlugin(mcpPlugin)
-      .addPlugin(loginPlugin)
-      .addPlugin(logoutPlugin)
-      // Add registry plugin to finalize SDK
-      .addPlugin(registryPlugin)
-  );
-}