@zapier/zapier-sdk-cli 0.8.4 → 0.10.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) {
+      const appSlugAndKey = app.slug ? `${app.slug} (${app.key})` : app.key;
+      console.log(`📦 Adding ${appSlugAndKey}...`);
+
+      try {
+        if (!app.version) {
+          console.warn(
+            `⚠️ Invalid implementation ID format for '${appSlugAndKey}': ${app.implementation_id}. Expected format: <implementationName>@<version>. Skipping...`,
+          );
+          continue;
+        }
+
+        // Update manifest using manifest plugin's function
+        const [manifestKey] = await context.updateManifestEntry(
+          app.key,
+          {
+            implementationName: app.key,
+            version: app.version,
+          },
+          configPath,
+        );
+
+        console.log(
+          `📝 Locked ${appSlugAndKey} to ${app.key}@${app.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 ${appSlugAndKey}`,
+            );
+          } else {
+            console.warn(
+              `⚠️ No matching authentication found for ${appSlugAndKey}`,
+            );
+          }
+        }
+
+        // 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 ${appSlugAndKey}: ${error}`,
+          );
+          // Continue even if type generation fails
+        }
+      } catch (error) {
+        console.warn(`⚠️ Failed to process ${appSlugAndKey}: ${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-utils.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { hasResolver, isPositional } from "@zapier/zapier-sdk";
+import { isPositional, type FunctionRegistryEntry } from "@zapier/zapier-sdk";
 
 // ============================================================================
 // Types
@@ -20,14 +20,17 @@ export interface CliParameter {
 // Schema Analysis
 // ============================================================================
 
-export function analyzeZodSchema(schema: z.ZodSchema): CliParameter[] {
+export function analyzeZodSchema(
+  schema: z.ZodSchema,
+  functionInfo?: FunctionRegistryEntry,
+): CliParameter[] {
   const parameters: CliParameter[] = [];
 
   if (schema instanceof z.ZodObject) {
     const shape = schema.shape;
 
-    for (const [key, fieldSchema] of Object.entries(shape)) {
-      const param = analyzeZodField(key, fieldSchema as z.ZodSchema);
+    for (const [key, fieldSchema] of Object.entries<z.ZodSchema>(shape)) {
+      const param = analyzeZodField(key, fieldSchema, functionInfo);
       if (param) {
         parameters.push(param);
       }
@@ -40,6 +43,7 @@ export function analyzeZodSchema(schema: z.ZodSchema): CliParameter[] {
 function analyzeZodField(
   name: string,
   schema: z.ZodSchema,
+  functionInfo?: FunctionRegistryEntry,
 ): CliParameter | null {
   let baseSchema = schema;
   let required = true;
@@ -77,6 +81,14 @@ function analyzeZodField(
     paramType = "string";
   }
 
+  // Check if this parameter has a resolver
+  let paramHasResolver = false;
+
+  // Check function-specific resolvers first
+  if (functionInfo?.resolvers?.[name]) {
+    paramHasResolver = true;
+  }
+
   // Extract resolver metadata
   return {
     name,
@@ -85,7 +97,7 @@ function analyzeZodField(
     description: schema.description,
     default: defaultValue,
     choices,
-    hasResolver: hasResolver(name),
+    hasResolver: paramHasResolver,
     isPositional: isPositional(schema),
   };
 }