@zapier/zapier-sdk 0.5.1 → 0.6.0

package/dist/plugins/listAuthentications/index.test.js

@@ -36,37 +36,46 @@ const mockAuthenticationsResponse = {
     previous: null,
 };
 const mockSlackApp = {
-    data: {
-        id: 1,
-        key: "slack",
-        title: "Slack",
-        hex_color: "#000000",
-        age_in_days: "100",
-        api_docs_url: "https://slack.com/api-docs",
-        app_profile_url: "https://slack.com",
-        banner: "https://slack.com/banner.png",
-        categories: [],
-        canonical_id: "slack",
-        zap_usage_count: 100,
-        zap_usage_count_last_updated: "2021-01-01",
-        zap_usage_count_last_updated_by: "user1",
-        zap_usage_count_last_updated_by_id: 123,
-        current_implementation_id: "SlackCLIAPI@1.21.1",
-    },
+    title: "Slack",
+    key: "SlackCLIAPI",
+    current_implementation_id: "SlackCLIAPI@1.21.1",
+    version: "1.21.1",
+    description: "Team communication platform",
+    slug: "slack",
 };
 describe("listAuthentications plugin", () => {
     let mockApiClient;
-    let mockGetApp;
+    let mockGetVersionedImplementationId;
     beforeEach(() => {
         vi.clearAllMocks();
         mockApiClient = {
             get: vi.fn().mockResolvedValue(mockAuthenticationsResponse),
         };
-        mockGetApp = vi.fn().mockResolvedValue(mockSlackApp);
+        mockGetVersionedImplementationId = vi
+            .fn()
+            .mockResolvedValue("SlackCLIAPI@1.21.1");
+    });
+    const apiPlugin = () => ({
+        context: {
+            api: mockApiClient,
+        },
+    });
+    const manifestPlugin = () => ({
+        context: {
+            manifest: null,
+            getVersionedImplementationId: mockGetVersionedImplementationId,
+            getManifestEntry: () => ({
+                implementationName: "SlackCLIAPI",
+                version: "1.21.1",
+            }),
+            getImplementation: vi.fn().mockResolvedValue(mockSlackApp),
+        },
     });
     function createTestSdk() {
-        return createSdk({ getApp: mockGetApp }, // Provide getApp in SDK
-        { api: mockApiClient, meta: {} }).addPlugin(listAuthenticationsPlugin);
+        return createSdk()
+            .addPlugin(apiPlugin)
+            .addPlugin(manifestPlugin)
+            .addPlugin(listAuthenticationsPlugin);
     }
     describe("schema validation", () => {
         it("should pass validation with empty options", async () => {
@@ -165,7 +174,7 @@ describe("listAuthentications plugin", () => {
     describe("data mapping", () => {
         it("should map is_stale to is_expired and marked_stale_at to expired_at", async () => {
             const sdk = createTestSdk();
-            const result = await sdk.listAuthentications({});
+            const result = await sdk.listAuthentications();
             expect(result.data[0].is_expired).toBe("false");
             expect(result.data[0].expired_at).toBe(null);
             expect(result.data[1].is_expired).toBe("true");
@@ -459,15 +468,7 @@ describe("listAuthentications plugin", () => {
     });
     describe("app key integration", () => {
         it("should handle app without current_implementation_id", async () => {
-            const appWithoutImplementation = {
-                data: {
-                    id: 123,
-                    key: "slack",
-                    title: "Slack",
-                    current_implementation_id: undefined,
-                },
-            };
-            mockGetApp.mockResolvedValue(appWithoutImplementation);
+            mockGetVersionedImplementationId.mockResolvedValue(null);
             const sdk = createTestSdk();
             await sdk.listAuthentications({ appKey: "slack" });
             // Should not add versionless_selected_api parameter
@@ -478,15 +479,7 @@ describe("listAuthentications plugin", () => {
             }));
         });
         it("should extract versionless API from versioned implementation ID", async () => {
-            const appWithVersionedApi = {
-                data: {
-                    id: 123,
-                    key: "slack",
-                    title: "Slack",
-                    current_implementation_id: "SlackCLIAPI@2.1.3",
-                },
-            };
-            mockGetApp.mockResolvedValue(appWithVersionedApi);
+            mockGetVersionedImplementationId.mockResolvedValue("SlackCLIAPI@2.1.3");
             const sdk = createTestSdk();
             await sdk.listAuthentications({ appKey: "slack" });
             expect(mockApiClient.get).toHaveBeenCalledWith("/api/v4/authentications/", expect.objectContaining({

package/dist/plugins/listAuthentications/schemas.d.ts

@@ -13,17 +13,17 @@ export declare const ListAuthenticationsSchema: z.ZodObject<{
     title?: string | undefined;
     search?: string | undefined;
     account_id?: string | undefined;
-    maxItems?: number | undefined;
-    pageSize?: number | undefined;
     appKey?: string | undefined;
+    pageSize?: number | undefined;
+    maxItems?: number | undefined;
     owner?: string | undefined;
 }, {
     title?: string | undefined;
     search?: string | undefined;
     account_id?: string | undefined;
-    maxItems?: number | undefined;
-    pageSize?: number | undefined;
     appKey?: string | undefined;
+    pageSize?: number | undefined;
+    maxItems?: number | undefined;
     owner?: string | undefined;
 }>;
 export type ListAuthenticationsOptions = z.infer<typeof ListAuthenticationsSchema>;

package/dist/plugins/listInputFields/index.d.ts

@@ -3,6 +3,7 @@ import type { ApiClient } from "../../api";
 import type { InputFieldItem } from "../../types/domain";
 import { ListInputFieldsSchema, type ListInputFieldsOptions } from "./schemas";
 import type { GetAppPluginProvides } from "../getApp";
+import { GetVersionedImplementationId } from "../manifest/schemas";
 export interface ListInputFieldsPluginProvides {
     listInputFields: (options?: ListInputFieldsOptions) => Promise<{
         data: InputFieldItem[];
@@ -23,6 +24,7 @@ export interface ListInputFieldsPluginProvides {
 export declare const listInputFieldsPlugin: Plugin<GetSdkType<GetAppPluginProvides>, // requires getApp in SDK
 {
     api: ApiClient;
-}, // requires api in context
+    getVersionedImplementationId: GetVersionedImplementationId;
+}, // requires api and getVersionedImplementationId in context
 ListInputFieldsPluginProvides>;
 //# sourceMappingURL=index.d.ts.map

package/dist/plugins/listInputFields/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/listInputFields/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EACL,qBAAqB,EACrB,KAAK,sBAAsB,EAE5B,MAAM,WAAW,CAAC;AAGnB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAkGtD,MAAM,WAAW,6BAA6B;IAC5C,eAAe,EAAE,CAAC,OAAO,CAAC,EAAE,sBAAsB,KAAK,OAAO,CAAC;QAC7D,IAAI,EAAE,cAAc,EAAE,CAAC;KACxB,CAAC,GACA,aAAa,CAAC;QAAE,IAAI,EAAE,cAAc,EAAE,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG;QAC/D,KAAK,IAAI,aAAa,CAAC,cAAc,CAAC,CAAC;KACxC,CAAC;IACJ,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,eAAe,EAAE;gBACf,WAAW,EAAE,OAAO,qBAAqB,CAAC;aAC3C,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,eAAO,MAAM,qBAAqB,EAAE,MAAM,CACxC,UAAU,CAAC,oBAAoB,CAAC,EAAE,yBAAyB;AAC3D;IAAE,GAAG,EAAE,SAAS,CAAA;CAAE,EAAE,0BAA0B;AAC9C,6BAA6B,CA2E9B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/listInputFields/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EACL,qBAAqB,EACrB,KAAK,sBAAsB,EAE5B,MAAM,WAAW,CAAC;AAGnB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AACtD,OAAO,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AAkGnE,MAAM,WAAW,6BAA6B;IAC5C,eAAe,EAAE,CAAC,OAAO,CAAC,EAAE,sBAAsB,KAAK,OAAO,CAAC;QAC7D,IAAI,EAAE,cAAc,EAAE,CAAC;KACxB,CAAC,GACA,aAAa,CAAC;QAAE,IAAI,EAAE,cAAc,EAAE,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG;QAC/D,KAAK,IAAI,aAAa,CAAC,cAAc,CAAC,CAAC;KACxC,CAAC;IACJ,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,eAAe,EAAE;gBACf,WAAW,EAAE,OAAO,qBAAqB,CAAC;aAC3C,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,eAAO,MAAM,qBAAqB,EAAE,MAAM,CACxC,UAAU,CAAC,oBAAoB,CAAC,EAAE,yBAAyB;AAC3D;IACE,GAAG,EAAE,SAAS,CAAC;IACf,4BAA4B,EAAE,4BAA4B,CAAC;CAC5D,EAAE,2DAA2D;AAC9D,6BAA6B,CA2E9B,CAAC"}

package/dist/plugins/listInputFields/index.js

@@ -86,15 +86,14 @@ function transformNeedToInputFieldItem(need) {
         items: itemsType ? { type: itemsType } : undefined,
     };
 }
-export const listInputFieldsPlugin = ({ sdk, context }) => {
+export const listInputFieldsPlugin = ({ context }) => {
     const listInputFields = createPaginatedFunction(async function listInputFieldsPage(options) {
         // Note: This function ignores pageSize and cursor since it's not actually paginated internally
-        const { api } = context;
+        const { api, getVersionedImplementationId } = context;
         // Extract parameters
         const { appKey, actionKey, actionType, authenticationId, inputs } = options;
-        // Use the getApp plugin
-        const appData = await sdk.getApp({ appKey });
-        const selectedApi = appData.data.current_implementation_id;
+        // Use the manifest plugin
+        const selectedApi = await getVersionedImplementationId(appKey);
         if (!selectedApi) {
             throw new ZapierConfigurationError("No current_implementation_id found for app", { configType: "current_implementation_id" });
         }
@@ -125,6 +124,7 @@ export const listInputFieldsPlugin = ({ sdk, context }) => {
         context: {
             meta: {
                 listInputFields: {
+                    categories: ["action"],
                     inputSchema: ListInputFieldsSchema,
                 },
             },

package/dist/plugins/listInputFields/index.test.js

@@ -37,18 +37,22 @@ const mockNeedsResponse = {
 };
 describe("listInputFields plugin", () => {
     let mockApiClient;
-    let mockGetApp;
+    let mockGetVersionedImplementationId;
     beforeEach(() => {
         vi.clearAllMocks();
         mockApiClient = {
             post: vi.fn().mockResolvedValue(mockNeedsResponse),
         };
-        mockGetApp = vi.fn().mockResolvedValue({
-            data: { current_implementation_id: "SlackCLIAPI@1.21.1" },
-        });
+        mockGetVersionedImplementationId = vi
+            .fn()
+            .mockResolvedValue("SlackCLIAPI@1.21.1");
     });
     function createTestSdk() {
-        return createSdk({ getApp: mockGetApp }, { api: mockApiClient, meta: {} }).addPlugin(listInputFieldsPlugin);
+        return createSdk({}, {}, {
+            api: mockApiClient,
+            meta: {},
+            getVersionedImplementationId: mockGetVersionedImplementationId,
+        }).addPlugin(listInputFieldsPlugin);
     }
     describe("schema validation", () => {
         it("should throw validation error for missing required fields", () => {
@@ -244,9 +248,7 @@ describe("listInputFields plugin", () => {
     });
     describe("error handling", () => {
         it("should throw ZapierConfigurationError when app has no current_implementation_id", async () => {
-            mockGetApp.mockResolvedValue({
-                data: { current_implementation_id: undefined },
-            });
+            mockGetVersionedImplementationId.mockResolvedValue(null);
             const sdk = createTestSdk();
             await expect(sdk.listInputFields({
                 appKey: "invalid",

package/dist/plugins/listInputFields/schemas.d.ts

@@ -14,17 +14,17 @@ export declare const ListInputFieldsSchema: z.ZodObject<{
     actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
     actionKey: string;
     authenticationId?: number | null | undefined;
-    maxItems?: number | undefined;
-    pageSize?: number | undefined;
     inputs?: Record<string, any> | undefined;
+    pageSize?: number | undefined;
+    maxItems?: number | undefined;
 }, {
     appKey: string;
     actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
     actionKey: string;
     authenticationId?: number | null | undefined;
-    maxItems?: number | undefined;
-    pageSize?: number | undefined;
     inputs?: Record<string, any> | undefined;
+    pageSize?: number | undefined;
+    maxItems?: number | undefined;
 }>;
 export type ListInputFieldsOptions = z.infer<typeof ListInputFieldsSchema>;
 export type ListInputFieldsError = import("../../types/errors").ZapierConfigurationError | import("../../types/errors").ZapierApiError | import("../../types/errors").ZapierAuthenticationError | import("../../types/errors").ZapierAppNotFoundError | import("../../types/errors").ZapierValidationError | import("../../types/errors").ZapierUnknownError;

package/dist/plugins/lockVersion/index.d.ts

@@ -0,0 +1,24 @@
+import type { Plugin, GetSdkType } from "../../types/plugin";
+import { LockVersionSchema } from "./schemas";
+import type { LockVersionOptions } from "./schemas";
+import type { AppItem } from "../../types/domain";
+import { ListAppsPluginProvides } from "../listApps";
+export interface LockVersionPluginProvides {
+    lockVersion: (options: LockVersionOptions & {
+        configPath?: string;
+    }) => Promise<{
+        data: AppItem;
+        configPath: string;
+    }>;
+    context: {
+        meta: {
+            lockVersion: {
+                inputSchema: typeof LockVersionSchema;
+            };
+        };
+    };
+}
+export declare const lockVersionPlugin: Plugin<GetSdkType<ListAppsPluginProvides>, // requires getApp in SDK
+{}, // requires manifest context
+LockVersionPluginProvides>;
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/lockVersion/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/lockVersion/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAE7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AACpD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAIlD,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAErD,MAAM,WAAW,yBAAyB;IACxC,WAAW,EAAE,CACX,OAAO,EAAE,kBAAkB,GAAG;QAAE,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,KAClD,OAAO,CAAC;QAAE,IAAI,EAAE,OAAO,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACpD,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,WAAW,EAAE;gBACX,WAAW,EAAE,OAAO,iBAAiB,CAAC;aACvC,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,eAAO,MAAM,iBAAiB,EAAE,MAAM,CACpC,UAAU,CAAC,sBAAsB,CAAC,EAAE,yBAAyB;AAC7D,EAAE,EAAE,4BAA4B;AAChC,yBAAyB,CAqF1B,CAAC"}

package/dist/plugins/lockVersion/index.js

@@ -0,0 +1,72 @@
+import { createFunction } from "../../utils/function-utils";
+import { LockVersionSchema } from "./schemas";
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { resolve } from "path";
+import { z } from "zod";
+export const lockVersionPlugin = ({ sdk }) => {
+    const lockVersion = createFunction(async function lockVersion(options) {
+        const { appKey, configPath = ".zapierrc" } = options;
+        const resolvedPath = resolve(configPath);
+        // Get the current app information
+        const appsIterator = sdk.listApps({ appKeys: [appKey] }).items();
+        const apps = [];
+        for await (const app of appsIterator) {
+            apps.push(app);
+            break; // Only need the first result
+        }
+        const app = apps[0];
+        // Extract implementation name and version from current_implementation_id
+        const currentImplementationId = app.current_implementation_id;
+        const [implementationName, version] = currentImplementationId.split("@");
+        if (!implementationName || !version) {
+            throw new Error(`Invalid implementation ID format: ${currentImplementationId}. Expected format: <implementationName>@<version>`);
+        }
+        // Read existing config or create new one
+        let config = { apps: {} };
+        if (existsSync(resolvedPath)) {
+            try {
+                const configContent = readFileSync(resolvedPath, "utf8");
+                config = JSON.parse(configContent);
+                // Ensure apps property exists
+                if (!config.apps) {
+                    config.apps = {};
+                }
+            }
+            catch (error) {
+                console.warn(`⚠️ Failed to parse existing config file, creating new one: ${error}`);
+                config = { apps: {} };
+            }
+        }
+        // Update the apps section
+        config.apps[appKey] = {
+            implementationName,
+            version,
+        };
+        // Write the updated config
+        writeFileSync(resolvedPath, JSON.stringify(config, null, 2));
+        return {
+            data: {
+                ...app,
+                implementationName,
+                version,
+            },
+            configPath: resolvedPath,
+        };
+    }, LockVersionSchema.extend({
+        configPath: z
+            .string()
+            .optional()
+            .describe("Path to .zapierrc file (defaults to '.zapierrc')"),
+    }));
+    return {
+        lockVersion,
+        context: {
+            meta: {
+                lockVersion: {
+                    categories: ["utility"],
+                    inputSchema: LockVersionSchema,
+                },
+            },
+        },
+    };
+};

package/dist/plugins/lockVersion/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/plugins/lockVersion/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../../src/plugins/lockVersion/index.test.ts"],"names":[],"mappings":""}

package/dist/plugins/lockVersion/index.test.js

@@ -0,0 +1,129 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { lockVersionPlugin } from "./index";
+import { createSdk } from "../../sdk";
+// Mock fs module
+vi.mock("fs", () => ({
+    readFileSync: vi.fn(),
+    writeFileSync: vi.fn(),
+    existsSync: vi.fn(),
+}));
+// Mock path module
+vi.mock("path", () => ({
+    resolve: vi.fn((path) => `/resolved/${path}`),
+}));
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { resolve } from "path";
+import { apiPlugin } from "../api";
+const mockReadFileSync = vi.mocked(readFileSync);
+const mockWriteFileSync = vi.mocked(writeFileSync);
+const mockExistsSync = vi.mocked(existsSync);
+const mockResolve = vi.mocked(resolve);
+describe("lockVersion plugin", () => {
+    let mockSdk;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockSdk = {
+            listApps: vi.fn().mockReturnValue({
+                items: vi.fn().mockReturnValue([
+                    {
+                        title: "Gmail",
+                        key: "GmailCLIAPI",
+                        current_implementation_id: "GmailCLIAPI@2.1.0",
+                        description: "Email service",
+                    },
+                ][Symbol.iterator]()),
+            }),
+        };
+    });
+    const listAppsPlugin = () => ({
+        listApps: mockSdk.listApps,
+        context: {
+            meta: {
+                listApps: {
+                    inputSchema: {},
+                },
+            },
+        },
+    });
+    function createTestSdk() {
+        return createSdk()
+            .addPlugin(apiPlugin)
+            .addPlugin(listAppsPlugin)
+            .addPlugin(lockVersionPlugin);
+    }
+    describe("version locking", () => {
+        it("should extract implementation name and version and write to file", async () => {
+            mockExistsSync.mockReturnValue(false);
+            mockResolve.mockReturnValue("/resolved/.zapierrc");
+            const sdk = createTestSdk();
+            const result = await sdk.lockVersion({ appKey: "gmail" });
+            expect(result.data.implementationName).toBe("GmailCLIAPI");
+            expect(result.data.version).toBe("2.1.0");
+            expect(result.data.current_implementation_id).toBe("GmailCLIAPI@2.1.0");
+            expect(result.configPath).toBe("/resolved/.zapierrc");
+            // Verify file was written
+            expect(mockWriteFileSync).toHaveBeenCalledWith("/resolved/.zapierrc", JSON.stringify({
+                apps: {
+                    gmail: {
+                        implementationName: "GmailCLIAPI",
+                        version: "2.1.0",
+                    },
+                },
+            }, null, 2));
+        });
+        it("should update existing .zapierrc file", async () => {
+            const existingConfig = {
+                apps: {
+                    slack: {
+                        implementationName: "SlackCLIAPI",
+                        version: "1.27.1",
+                    },
+                },
+            };
+            mockExistsSync.mockReturnValue(true);
+            mockReadFileSync.mockReturnValue(JSON.stringify(existingConfig));
+            mockResolve.mockReturnValue("/resolved/.zapierrc");
+            const sdk = createTestSdk();
+            const result = await sdk.lockVersion({ appKey: "gmail" });
+            expect(mockReadFileSync).toHaveBeenCalledWith("/resolved/.zapierrc", "utf8");
+            expect(result.configPath).toBe("/resolved/.zapierrc");
+            // Verify file was updated with both apps
+            expect(mockWriteFileSync).toHaveBeenCalledWith("/resolved/.zapierrc", JSON.stringify({
+                apps: {
+                    slack: {
+                        implementationName: "SlackCLIAPI",
+                        version: "1.27.1",
+                    },
+                    gmail: {
+                        implementationName: "GmailCLIAPI",
+                        version: "2.1.0",
+                    },
+                },
+            }, null, 2));
+        });
+        it("should handle invalid implementation ID format", async () => {
+            mockSdk.listApps = vi.fn().mockReturnValue({
+                items: vi.fn().mockReturnValue([
+                    {
+                        title: "Invalid App",
+                        key: "InvalidApp",
+                        current_implementation_id: "InvalidFormat",
+                    },
+                ][Symbol.iterator]()),
+            });
+            const sdk = createTestSdk();
+            await expect(sdk.lockVersion({ appKey: "invalid" })).rejects.toThrow("Invalid implementation ID format: InvalidFormat. Expected format: <implementationName>@<version>");
+        });
+        it("should use custom config path when provided", async () => {
+            mockExistsSync.mockReturnValue(false);
+            mockResolve.mockReturnValue("/resolved/custom-config.json");
+            const sdk = createTestSdk();
+            const result = await sdk.lockVersion({
+                appKey: "gmail",
+                configPath: "custom-config.json",
+            });
+            expect(mockResolve).toHaveBeenCalledWith("custom-config.json");
+            expect(result.configPath).toBe("/resolved/custom-config.json");
+        });
+    });
+});

package/dist/plugins/lockVersion/schemas.d.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+export declare const LockVersionSchema: z.ZodObject<{
+    appKey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    appKey: string;
+}, {
+    appKey: string;
+}>;
+export type LockVersionOptions = z.infer<typeof LockVersionSchema>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/plugins/lockVersion/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/lockVersion/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,iBAAiB;;;;;;EAI5B,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/plugins/lockVersion/schemas.js

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export const LockVersionSchema = z.object({
+    appKey: z
+        .string()
+        .describe("The app key to lock version for (e.g., 'slack', 'gmail')"),
+});

package/dist/plugins/manifest/index.d.ts

@@ -0,0 +1,24 @@
+import type { GetImplementation, GetManifestEntry, GetVersionedImplementationId, Manifest } from "./schemas";
+import { ManifestPluginOptionsSchema } from "./schemas";
+import type { GetSdkType, Plugin } from "../../types/plugin";
+import { z } from "zod";
+import { ApiClient } from "../../api";
+import { ListAppsPluginProvides } from "../listApps";
+export type ManifestPluginOptions = z.infer<typeof ManifestPluginOptionsSchema>;
+export interface ManifestPluginProvides {
+    context: {
+        manifest: Manifest | null;
+        getVersionedImplementationId: GetVersionedImplementationId;
+        getManifestEntry: GetManifestEntry;
+        getImplementation: GetImplementation;
+    };
+}
+/**
+ * Load manifest from a file path synchronously
+ * Supports local files (Node.js only)
+ */
+export declare function loadManifestFromFile(filePath: string): Manifest | null;
+export declare const manifestPlugin: Plugin<GetSdkType<ListAppsPluginProvides>, {
+    api: ApiClient;
+}, ManifestPluginProvides>;
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/manifest/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/manifest/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,iBAAiB,EACjB,gBAAgB,EAChB,4BAA4B,EAC5B,QAAQ,EACT,MAAM,WAAW,CAAC;AACnB,OAAO,EAAkB,2BAA2B,EAAE,MAAM,WAAW,CAAC;AACxE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAOrD,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE;QACP,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;QAC1B,4BAA4B,EAAE,4BAA4B,CAAC;QAC3D,gBAAgB,EAAE,gBAAgB,CAAC;QACnC,iBAAiB,EAAE,iBAAiB,CAAC;KACtC,CAAC;CACH;AA2BD;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAUtE;AAcD,eAAO,MAAM,cAAc,EAAE,MAAM,CACjC,UAAU,CAAC,sBAAsB,CAAC,EAClC;IAAE,GAAG,EAAE,SAAS,CAAA;CAAE,EAClB,sBAAsB,CAoFvB,CAAC"}

package/dist/plugins/manifest/index.js

@@ -0,0 +1,119 @@
+import { readFileSync } from "fs";
+import { resolve } from "path";
+import { ManifestSchema } from "./schemas";
+import { normalizeImplementationToAppItem, splitVersionedKey, } from "../../utils/domain-utils";
+/**
+ * Parse manifest content from a string
+ */
+function parseManifestContent(content, source) {
+    try {
+        const parsed = JSON.parse(content);
+        if (parsed?.apps && typeof parsed?.apps === "object") {
+            const result = ManifestSchema.safeParse(parsed);
+            if (result.success) {
+                return result.data;
+            }
+            console.warn(`⚠️ Invalid manifest format in ${source}: ${result.error}`);
+        }
+        return null;
+    }
+    catch (error) {
+        console.warn(`⚠️ Failed to parse manifest from ${source}:`, error);
+        return null;
+    }
+}
+/**
+ * Load manifest from a file path synchronously
+ * Supports local files (Node.js only)
+ */
+export function loadManifestFromFile(filePath) {
+    try {
+        // Resolve relative paths relative to current working directory
+        const resolvedPath = resolve(filePath);
+        const content = readFileSync(resolvedPath, "utf8");
+        return parseManifestContent(content, resolvedPath);
+    }
+    catch (error) {
+        console.warn(`⚠️ Failed to load manifest from ${filePath}:`, error);
+        return null;
+    }
+}
+const emitWarning = (appKey) => {
+    console.warn(`\n${"⚠️".padEnd(3)} ${"WARNING".padEnd(8)} No manifest version found for '${appKey}'`);
+    console.warn(`   ${"↳".padEnd(3)} Using a manifest ensures version locking and prevents unexpected behavior due to version changes.`);
+    console.warn(`   ${"↳".padEnd(3)} Generate/update the manifest with: \`zapier-sdk update-manifest ${appKey}\`\n`);
+};
+export const manifestPlugin = (params) => {
+    const { sdk, context } = params;
+    const { api, options } = context;
+    const { manifestPath = ".zapierrc", manifest } = options || {};
+    const resolvedManifest = (() => {
+        // If manifest is provided directly, use it
+        if (manifest) {
+            return manifest;
+        }
+        // If manifestPath is provided, load from file
+        if (manifestPath) {
+            return loadManifestFromFile(manifestPath);
+        }
+        return null;
+    })();
+    const getManifestEntry = (appKey) => {
+        return resolvedManifest?.apps?.[appKey] || null;
+    };
+    const getImplementation = async (appKey) => {
+        let selectedApi = null;
+        const manifestImplementation = resolvedManifest?.apps?.[appKey];
+        const [versionlessAppKey, version] = splitVersionedKey(appKey);
+        // Use versioned app key if provided
+        if (version) {
+            selectedApi = `${versionlessAppKey}@${version}`;
+            // Otherwise, use manifest entry if available
+        }
+        else if (manifestImplementation) {
+            selectedApi = `${manifestImplementation.implementationName}@${manifestImplementation.version || "latest"}`;
+        }
+        if (selectedApi) {
+            const searchParams = {
+                selected_apis: selectedApi,
+            };
+            const implementationData = await api.get("/api/v4/implementations/", {
+                searchParams,
+            });
+            const implementationResults = implementationData.results[0];
+            if (!implementationResults)
+                return null;
+            return normalizeImplementationToAppItem(implementationResults);
+        }
+        emitWarning(appKey);
+        const appsIterator = sdk.listApps({ appKeys: [appKey] }).items();
+        const apps = [];
+        for await (const app of appsIterator) {
+            apps.push(app);
+            break; // Only need the first result
+        }
+        if (apps.length === 0) {
+            return null;
+        }
+        const app = apps[0];
+        return app;
+    };
+    const getVersionedImplementationId = async (appKey) => {
+        const manifestEntry = getManifestEntry(appKey);
+        if (manifestEntry) {
+            return `${manifestEntry.implementationName}@${manifestEntry.version || "latest"}`;
+        }
+        const implementation = await getImplementation(appKey);
+        if (!implementation)
+            return null;
+        return implementation.current_implementation_id;
+    };
+    return {
+        context: {
+            manifest: resolvedManifest,
+            getVersionedImplementationId,
+            getManifestEntry,
+            getImplementation,
+        },
+    };
+};