@zapier/zapier-sdk-cli 0.16.1 → 0.16.3

package/src/plugins/buildManifest/index.ts

@@ -1,131 +0,0 @@
-import type {
-  Plugin,
-  GetSdkType,
-  GetContextType,
-  ListAppsPluginProvides,
-  ManifestPluginProvides,
-  AppItem,
-  Manifest,
-} from "@zapier/zapier-sdk";
-import {
-  createFunction,
-  ZapierValidationError,
-  ZapierUnknownError,
-} from "@zapier/zapier-sdk";
-import {
-  BuildManifestSchema,
-  type BuildManifestOptions,
-  type BuildManifestResult,
-} from "./schemas";
-import { createManifestEntry } from "../../utils/manifest-helpers";
-
-export interface BuildManifestPluginProvides {
-  buildManifest: (
-    options: BuildManifestOptions,
-  ) => Promise<BuildManifestResult>;
-  context: {
-    meta: {
-      buildManifest: {
-        inputSchema: typeof BuildManifestSchema;
-      };
-    };
-  };
-}
-
-export const buildManifestPlugin: Plugin<
-  GetSdkType<ListAppsPluginProvides>,
-  GetContextType<ManifestPluginProvides>,
-  BuildManifestPluginProvides
-> = ({ sdk, context }) => {
-  const buildManifest = createFunction(async function buildManifest(
-    options: BuildManifestOptions,
-  ): Promise<BuildManifestResult> {
-    const { appKeys, skipWrite = false, configPath, onProgress } = options;
-
-    // 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 {};
-    }
-
-    let updatedManifest: Manifest | undefined;
-
-    // Process each app
-    for (const app of apps) {
-      onProgress?.({
-        type: "app_processing_start",
-        appKey: app.key,
-        slug: app.slug,
-      });
-
-      try {
-        const manifestEntry = createManifestEntry(app);
-
-        onProgress?.({
-          type: "manifest_entry_built",
-          appKey: app.key,
-          manifestKey: manifestEntry.implementationName,
-          version: manifestEntry.version || "",
-        });
-
-        const { key: updatedManifestKey, manifest } =
-          await context.updateManifestEntry({
-            appKey: app.key,
-            entry: manifestEntry,
-            configPath,
-            skipWrite,
-            manifest: updatedManifest,
-          });
-
-        updatedManifest = manifest;
-
-        onProgress?.({
-          type: "manifest_updated",
-          appKey: app.key,
-          manifestKey: updatedManifestKey,
-          version: manifestEntry.version || "",
-        });
-
-        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 { manifest: updatedManifest };
-  }, BuildManifestSchema);
-
-  return {
-    buildManifest,
-    context: {
-      meta: {
-        buildManifest: {
-          categories: ["utility"],
-          inputSchema: BuildManifestSchema,
-        },
-      },
-    },
-  };
-};

package/src/plugins/buildManifest/schemas.ts

@@ -1,55 +0,0 @@
-import { z } from "zod";
-import type { AppItem, Manifest } from "@zapier/zapier-sdk";
-
-export const BuildManifestSchema = 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 build manifest entries for (e.g., 'slack', 'github', 'trello')",
-      ),
-    skipWrite: z
-      .boolean()
-      .optional()
-      .describe(
-        "If true, returns manifest entries without writing to disk. If false or omitted, writes to the manifest file.",
-      ),
-    configPath: z
-      .string()
-      .optional()
-      .describe(
-        "Path to the manifest file. Only used when skipWrite is false or omitted.",
-      ),
-  })
-  .describe(
-    "Build manifest entries for apps - can optionally write to disk or just return JSON",
-  );
-
-export type BuildManifestOptions = z.infer<typeof BuildManifestSchema> & {
-  onProgress?: (event: ManifestBuildProgressEvent) => void;
-};
-
-export type ManifestBuildProgressEvent =
-  | { type: "apps_lookup_start"; count: number }
-  | { type: "app_found"; app: AppItem }
-  | { type: "apps_lookup_complete"; count: number }
-  | { type: "app_processing_start"; appKey: string; slug?: string }
-  | {
-      type: "manifest_entry_built";
-      appKey: string;
-      manifestKey: string;
-      version: string;
-    }
-  | {
-      type: "manifest_updated";
-      appKey: string;
-      manifestKey: string;
-      version: string;
-    }
-  | { type: "app_processing_complete"; appKey: string }
-  | { type: "app_processing_error"; appKey: string; error: string };
-
-export interface BuildManifestResult {
-  manifest?: Manifest;
-}

package/src/plugins/bundleCode/index.ts

@@ -1,128 +0,0 @@
-import type { Plugin } from "@zapier/zapier-sdk";
-import { BundleCodeSchema, type BundleCodeOptions } from "./schemas";
-import { createFunction } from "@zapier/zapier-sdk";
-import { buildSync } from "esbuild";
-import * as fs from "fs";
-import * as path from "path";
-
-export interface BundleCodePluginProvides {
-  bundleCode: (options: BundleCodeOptions) => Promise<string>;
-  context: {
-    meta: {
-      bundleCode: {
-        inputSchema: typeof BundleCodeSchema;
-      };
-    };
-  };
-}
-
-export const bundleCodePlugin: Plugin<
-  {}, // requires no existing SDK methods
-  {}, // requires no context
-  BundleCodePluginProvides
-> = () => {
-  const bundleCodeWithSdk = createFunction(async function bundleCodeWithSdk(
-    options: BundleCodeOptions,
-  ): Promise<string> {
-    return await bundleCode(options);
-  }, BundleCodeSchema);
-
-  return {
-    bundleCode: bundleCodeWithSdk,
-    context: {
-      meta: {
-        bundleCode: {
-          categories: ["utility"],
-          inputSchema: BundleCodeSchema,
-        },
-      },
-    },
-  };
-};
-
-class ZapierBundleError extends Error {
-  public readonly code = "ZAPIER_BUNDLE_ERROR";
-  public readonly details?: string[];
-  public readonly originalError?: Error;
-
-  constructor(message: string, details?: string[], originalError?: Error) {
-    super(message);
-    this.name = "ZapierBundleError";
-    this.details = details;
-    this.originalError = originalError;
-  }
-}
-
-/**
- * Bundle TypeScript code into executable JavaScript (CLI version)
- */
-async function bundleCode(options: BundleCodeOptions): Promise<string> {
-  const {
-    input,
-    output,
-    target = "es2020",
-    cjs = false,
-    minify = false,
-    string: returnString = false,
-  } = options;
-
-  // Resolve input path
-  const resolvedInput = path.resolve(process.cwd(), input);
-
-  try {
-    // Bundle with esbuild
-    const result = buildSync({
-      entryPoints: [resolvedInput],
-      bundle: true,
-      platform: "node",
-      target: target,
-      format: cjs ? "cjs" : "esm",
-      minify: 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) {
-      // Output as quoted string for node -e using JSON.stringify
-      finalOutput = JSON.stringify(bundledCode);
-    }
-
-    // Write to file if output path specified
-    if (output) {
-      fs.mkdirSync(path.dirname(output), { recursive: true });
-      fs.writeFileSync(output, finalOutput, "utf8");
-    }
-
-    return finalOutput;
-  } catch (error) {
-    // If it's already a ZapierBundleError, re-throw as-is
-    if (error instanceof ZapierBundleError) {
-      throw error;
-    }
-    throw new ZapierBundleError(
-      `Bundle failed: ${
-        error instanceof Error ? error.message : "Unknown error"
-      }`,
-      undefined,
-      error instanceof Error ? error : undefined,
-    );
-  }
-}

package/src/plugins/bundleCode/schemas.ts

@@ -1,24 +0,0 @@
-import { z } from "zod";
-import { OutputPropertySchema } from "@zapier/zapier-sdk";
-
-// Bundle code schema - mirrors the original from SDK but for CLI use
-export const BundleCodeSchema = z
-  .object({
-    input: z.string().min(1).describe("Input TypeScript file path to bundle"),
-    output: OutputPropertySchema.optional().describe(
-      "Output file path (defaults to input with .js extension)",
-    ),
-    string: z
-      .boolean()
-      .optional()
-      .describe("Return bundled code as string instead of writing to file"),
-    minify: z.boolean().optional().describe("Minify the bundled output"),
-    target: z.string().optional().describe("ECMAScript target version"),
-    cjs: z
-      .boolean()
-      .optional()
-      .describe("Output CommonJS format instead of ESM"),
-  })
-  .describe("Bundle TypeScript code into executable JavaScript");
-
-export type BundleCodeOptions = z.infer<typeof BundleCodeSchema>;