@zapier/zapier-sdk-cli 0.8.3 → 0.9.0

package/src/plugins/add/index.test.ts

@@ -0,0 +1,58 @@
+import { describe, it, expect } from "vitest";
+import { AddSchema } from "./schemas";
+import { DEFAULT_CONFIG_PATH } from "@zapier/zapier-sdk";
+
+describe("Add plugin", () => {
+  describe("schema validation", () => {
+    it("should accept valid options with authenticationIds", () => {
+      const result = AddSchema.safeParse({
+        appKeys: ["slack", "gmail"],
+        authenticationIds: ["123", "456"],
+        configPath: DEFAULT_CONFIG_PATH,
+        typesOutput: "src/types",
+      });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.authenticationIds).toEqual(["123", "456"]);
+      }
+    });
+
+    it("should accept options without authenticationIds", () => {
+      const result = AddSchema.safeParse({
+        appKeys: ["slack"],
+      });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.authenticationIds).toBeUndefined();
+      }
+    });
+
+    it("should reject invalid authenticationIds type", () => {
+      const result = AddSchema.safeParse({
+        appKeys: ["slack"],
+        authenticationIds: "123", // Should be array
+      });
+
+      expect(result.success).toBe(false);
+    });
+
+    it("should reject authenticationIds with non-string items", () => {
+      const result = AddSchema.safeParse({
+        appKeys: ["slack"],
+        authenticationIds: [123, 456], // Should be strings
+      });
+
+      expect(result.success).toBe(false);
+    });
+
+    it("should require at least one appKey", () => {
+      const result = AddSchema.safeParse({
+        appKeys: [],
+      });
+
+      expect(result.success).toBe(false);
+    });
+  });
+});

package/src/plugins/add/index.ts

@@ -0,0 +1,187 @@
+import type {
+  Plugin,
+  GetSdkType,
+  GetContextType,
+  ListActionsPluginProvides,
+  ListAppsPluginProvides,
+  ListInputFieldsPluginProvides,
+  ListAuthenticationsPluginProvides,
+  ManifestPluginProvides,
+} from "@zapier/zapier-sdk";
+import { createFunction } from "@zapier/zapier-sdk";
+import { AddSchema, type AddOptions } from "./schemas";
+import { AstTypeGenerator } from "./ast-generator";
+import { mkdir, access, writeFile } from "fs/promises";
+import { resolve, join } from "path";
+
+/**
+ * Detect the best default directory for TypeScript types
+ * Looks for src or lib directories, falls back to current directory
+ */
+async function detectTypesOutputDirectory(): Promise<string> {
+  // Check for common source directories in priority order
+  const candidates = ["src", "lib"];
+
+  for (const candidate of candidates) {
+    try {
+      await access(candidate);
+      return join(candidate, "zapier", "apps");
+    } catch {
+      // Directory doesn't exist, continue to next candidate
+    }
+  }
+
+  // Fall back to current directory
+  return "./zapier/apps/";
+}
+export interface AddPluginProvides {
+  add: (options: AddOptions) => Promise<void>;
+  context: {
+    meta: {
+      add: {
+        inputSchema: typeof AddSchema;
+      };
+    };
+  };
+}
+
+export const addPlugin: Plugin<
+  GetSdkType<
+    ListAppsPluginProvides &
+      ListActionsPluginProvides &
+      ListInputFieldsPluginProvides &
+      ListAuthenticationsPluginProvides &
+      ManifestPluginProvides
+  >,
+  GetContextType<ManifestPluginProvides>,
+  AddPluginProvides
+> = ({ sdk, context }) => {
+  const add = createFunction(async function add(options: AddOptions) {
+    const {
+      appKeys,
+      authenticationIds,
+      configPath,
+      typesOutput = await detectTypesOutputDirectory(),
+    } = options;
+
+    const resolvedTypesOutput = resolve(typesOutput);
+
+    // Ensure types output directory exists
+    await mkdir(resolvedTypesOutput, { recursive: true });
+
+    // Get apps using listApps (which respects existing manifest for version locking)
+    console.log(`📦 Looking up ${appKeys.length} app(s)...`);
+    const appsIterator = sdk.listApps({ appKeys }).items();
+    const apps = [];
+    for await (const app of appsIterator) {
+      apps.push(app);
+    }
+
+    if (apps.length === 0) {
+      console.warn("⚠️ No apps found");
+      return;
+    }
+
+    // Fetch authentications if provided
+    let authentications = [];
+    if (authenticationIds && authenticationIds.length > 0) {
+      console.log(
+        `🔐 Looking up ${authenticationIds.length} authentication(s)...`,
+      );
+      const authsIterator = sdk
+        .listAuthentications({ authenticationIds })
+        .items();
+      for await (const auth of authsIterator) {
+        authentications.push(auth);
+      }
+      console.log(`🔐 Found ${authentications.length} authentication(s)`);
+    }
+
+    // Process each app
+    for (const app of apps) {
+      console.log(`📦 Adding ${app.key}...`);
+
+      try {
+        // Extract implementation name and version from current_implementation_id
+        const currentImplementationId = app.current_implementation_id;
+        const [implementationName, version] =
+          currentImplementationId.split("@");
+
+        if (!implementationName || !version) {
+          console.warn(
+            `⚠️ Invalid implementation ID format for '${app.key}': ${currentImplementationId}. Expected format: <implementationName>@<version>. Skipping...`,
+          );
+          continue;
+        }
+
+        // Update manifest using manifest plugin's function
+        const [manifestKey] = await context.updateManifestEntry(
+          app.key,
+          {
+            implementationName,
+            version,
+          },
+          configPath,
+        );
+
+        console.log(
+          `📝 Locked ${app.key} to ${implementationName}@${version} using key '${manifestKey}'`,
+        );
+
+        // Find matching authentication for this app if authentications were provided
+        let authenticationId: number | undefined;
+        if (authentications.length > 0) {
+          // Match authentication by app_key
+          const matchingAuth = authentications.find((auth) => {
+            return auth.app_key === app.key;
+          });
+
+          if (matchingAuth) {
+            authenticationId = matchingAuth.id;
+            console.log(
+              `🔐 Using authentication ${authenticationId} (${matchingAuth.title}) for ${app.key}`,
+            );
+          } else {
+            console.warn(`⚠️ No matching authentication found for ${app.key}`);
+          }
+        }
+
+        // Generate types using the manifest key for consistency
+        const typesPath = join(resolvedTypesOutput, `${manifestKey}.d.ts`);
+
+        try {
+          // Use AST-based generator directly
+          const generator = new AstTypeGenerator();
+          const typeDefinitions = await generator.generateTypes({
+            appKey: manifestKey,
+            authenticationId,
+            sdk,
+          });
+
+          // Write to file
+          await writeFile(typesPath, typeDefinitions, "utf8");
+          console.log(`🔧 Generated types for ${manifestKey} at ${typesPath}`);
+        } catch (error) {
+          console.warn(`⚠️ Failed to generate types for ${app.key}: ${error}`);
+          // Continue even if type generation fails
+        }
+      } catch (error) {
+        console.warn(`⚠️ Failed to process ${app.key}: ${error}`);
+      }
+    }
+
+    console.log(`✅ Added ${apps.length} app(s) to manifest`);
+  }, AddSchema);
+
+  return {
+    add,
+    context: {
+      meta: {
+        add: {
+          categories: ["utility"],
+          inputSchema: AddSchema,
+        },
+      },
+    },
+  };
+};

package/src/plugins/add/schemas.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { DEFAULT_CONFIG_PATH } from "@zapier/zapier-sdk";
+
+export const AddSchema = z.object({
+  appKeys: z
+    .array(z.string().min(1, "App key cannot be empty"))
+    .min(1, "At least one app key is required"),
+  authenticationIds: z
+    .array(z.string())
+    .optional()
+    .describe("Authentication IDs to use for type generation"),
+  configPath: z
+    .string()
+    .optional()
+    .describe(
+      `Path to Zapier config file (defaults to '${DEFAULT_CONFIG_PATH}')`,
+    ),
+  typesOutput: z
+    .string()
+    .optional()
+    .describe(
+      "Directory for TypeScript type files (defaults to (src|lib|.)/zapier/apps/)",
+    ),
+});
+
+export type AddOptions = z.infer<typeof AddSchema>;

package/src/plugins/getLoginConfigPath/index.ts

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,10 @@
+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,6 +1,6 @@
 export { loginPlugin } from "./login";
 export { logoutPlugin } from "./logout";
 export { mcpPlugin } from "./mcp";
-export { generateTypesPlugin } from "./generateTypes";
 export { bundleCodePlugin } from "./bundleCode";
-export { getConfigPathPlugin } from "./getConfigPath";
+export { getLoginConfigPathPlugin } from "./getLoginConfigPath";
+export { addPlugin } from "./add";

package/src/sdk.ts

@@ -7,9 +7,9 @@ import {
   loginPlugin,
   logoutPlugin,
   mcpPlugin,
-  generateTypesPlugin,
   bundleCodePlugin,
-  getConfigPathPlugin,
+  getLoginConfigPathPlugin,
+  addPlugin,
 } from "./plugins/index";
 
 export interface ZapierCliSdkOptions {
@@ -29,9 +29,9 @@ export function createZapierCliSdk(
   });
 
   // Add CLI-specific plugins before registry
-  sdk = sdk.addPlugin(generateTypesPlugin);
   sdk = sdk.addPlugin(bundleCodePlugin);
-  sdk = sdk.addPlugin(getConfigPathPlugin);
+  sdk = sdk.addPlugin(getLoginConfigPathPlugin);
+  sdk = sdk.addPlugin(addPlugin);
   sdk = sdk.addPlugin(mcpPlugin);
   sdk = sdk.addPlugin(loginPlugin);
   sdk = sdk.addPlugin(logoutPlugin);

package/src/utils/cli-generator.ts

@@ -436,6 +436,9 @@ function addCommand(
 ): void {
   const command = program.command(commandName).description(config.description);
 
+  // Track whether we've already used a positional array parameter
+  let hasPositionalArray = false;
+
   // Add parameters to command
   config.parameters.forEach((param) => {
     // Convert camelCase to kebab-case for CLI display
@@ -447,6 +450,25 @@ function addCommand(
         `[${kebabName}]`,
         param.description || `${kebabName} parameter`,
       );
+    } else if (
+      param.required &&
+      param.type === "array" &&
+      !hasPositionalArray
+    ) {
+      // First required array parameter becomes a variadic positional argument
+      hasPositionalArray = true;
+      command.argument(
+        `<${kebabName}...>`,
+        param.description || `${kebabName} parameter`,
+      );
+    } else if (param.required && param.type === "array") {
+      // Subsequent required array parameters become required flags
+      const flags = [`--${kebabName}`];
+      const flagSignature = flags.join(", ") + ` <values...>`;
+      command.requiredOption(
+        flagSignature,
+        param.description || `${kebabName} parameter (required)`,
+      );
     } else if (param.required) {
       // Required parameters without resolvers become required positional arguments
       command.argument(

package/tsup.config.ts

@@ -17,7 +17,7 @@ export default defineConfig({
     };
   },
   // Make the optional CLI login package external so it doesn't cause build issues
-  external: ["@zapier/zapier-sdk-cli-login"],
+  external: ["@zapier/zapier-sdk-cli-login", "typescript"],
   // Use the build-specific tsconfig for tsup
   tsconfig: "tsconfig.build.json",
 });

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

@@ -1,21 +0,0 @@
-import type { Plugin, GetSdkType, ListActionsPluginProvides, ListInputFieldsPluginProvides, ManifestPluginProvides } from "@zapier/zapier-sdk";
-import { GenerateTypesSchema, type GenerateTypesOptions } from "./schemas";
-export interface GenerateTypesPluginProvides {
-    generateTypes: (options: GenerateTypesOptions) => Promise<string>;
-    context: {
-        meta: {
-            generateTypes: {
-                inputSchema: typeof GenerateTypesSchema;
-            };
-        };
-    };
-}
-export declare const generateTypesPlugin: Plugin<GetSdkType<ListActionsPluginProvides & ListInputFieldsPluginProvides & ManifestPluginProvides>, // requires these SDK methods
-{}, // requires no context
-GenerateTypesPluginProvides>;
-/**
- * Generate TypeScript types for a specific app (CLI version)
- */
-export declare function generateTypes(options: GenerateTypesOptions & {
-    sdk: GetSdkType<ListActionsPluginProvides & ListInputFieldsPluginProvides & ManifestPluginProvides>;
-}): Promise<string>;