@zapier/zapier-sdk 0.33.0 → 0.33.2

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

@@ -1,1179 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { manifestPlugin, readManifestFromFile, findManifestEntry, getPreferredManifestEntryKey, } from "./index";
-import { createSdk } from "../../sdk";
-import { eventEmissionPlugin } from "../eventEmission";
-// Mock file-utils module
-vi.mock("../../utils/file-utils", () => ({
-    readFile: vi.fn(),
-    writeFile: vi.fn(),
-    resolve: vi.fn((path) => Promise.resolve(`/resolved/${path}`)),
-}));
-import { readFile, resolve } from "../../utils/file-utils";
-const mockReadFile = vi.mocked(readFile);
-const mockResolve = vi.mocked(resolve);
-const mockResolveAppKeys = vi.fn();
-describe("manifestPlugin", () => {
-    const mockManifest = {
-        apps: {
-            slack: {
-                implementationName: "SlackCLIAPI",
-                version: "1.21.1",
-            },
-            "google-sheets": {
-                implementationName: "GoogleSheetsCLIAPI",
-                version: "2.0.0",
-            },
-        },
-    };
-    const mockManifestContent = JSON.stringify(mockManifest);
-    let mockApiClient;
-    let mockSdk;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        vi.spyOn(console, "warn").mockImplementation(() => { });
-        mockApiClient = {
-            get: vi.fn().mockImplementation((url, options) => {
-                if (url === "/zapier/api/v4/implementations/") {
-                    // Mock for manifest entries (versioned)
-                    return Promise.resolve({
-                        count: 1,
-                        next: null,
-                        previous: null,
-                        results: [
-                            {
-                                selected_api: "SlackCLIAPI@1.29.0",
-                                app_id: null,
-                                service_id: null,
-                                auth_type: "oauth",
-                                auth_fields: [
-                                    {
-                                        key: "access_token",
-                                        required: true,
-                                        type: "unicode",
-                                        computed: true,
-                                    },
-                                ],
-                                is_deprecated: false,
-                                is_private_only: false,
-                                is_invite_only: false,
-                                is_beta: false,
-                                is_premium: false,
-                                is_hidden: false,
-                                name: "Slack (1.29.0)",
-                                name_clean: "Slack",
-                                version: "1.29.0",
-                                slug: null,
-                                images: {
-                                    url_16x16: "https://zapier-images.imgix.net/storage/services/6cf3f5a461feadfba7abc93c4c395b33_2.png?auto=format%2Ccompress&fit=crop&h=16&ixlib=python-3.0.0&q=50&w=16",
-                                    url_32x32: "https://zapier-images.imgix.net/storage/services/6cf3f5a461feadfba7abc93c4c395b33_2.png?auto=format%2Ccompress&fit=crop&h=32&ixlib=python-3.0.0&q=50&w=32",
-                                    url_64x64: "https://zapier-images.imgix.net/storage/services/6cf3f5a461feadfba7abc93c4c395b33_2.png?auto=format%2Ccompress&fit=crop&h=64&ixlib=python-3.0.0&q=50&w=64",
-                                    url_128x128: "https://zapier-images.imgix.net/storage/services/6cf3f5a461feadfba7abc93c4c395b33_2.png?auto=format%2Ccompress&fit=crop&h=128&ixlib=python-3.0.0&q=50&w=128",
-                                },
-                                primary_color: null,
-                                secondary_color: null,
-                                classification: "third-party",
-                                current_implementation: "SlackCLIAPI@1.30.0",
-                                is_adoptable: true,
-                                is_usable: true,
-                                update_cta_level: "info",
-                                update_cta_message: "This version is legacy. Consider updating to the latest version for better support.",
-                                badges: [
-                                    {
-                                        label: "Legacy",
-                                        color: "primary",
-                                        tooltip_markdown: "This version is legacy. Consider updating to the latest version for better support.",
-                                    },
-                                ],
-                            },
-                        ],
-                    });
-                }
-                else if (url === "/zapier/api/v4/implementations-meta/lookup/") {
-                    // Mock for implementations-meta/lookup fallback
-                    const searchParams = options?.searchParams || {};
-                    // Check if we're looking for a nonexistent app
-                    if (searchParams.slugs?.includes("nonexistent") ||
-                        searchParams.selected_apis?.includes("nonexistent")) {
-                        return Promise.resolve({
-                            count: 0,
-                            next: null,
-                            previous: null,
-                            results: [],
-                        });
-                    }
-                    // Return successful response for known apps (like slack)
-                    return Promise.resolve({
-                        count: 1,
-                        next: null,
-                        previous: null,
-                        results: [
-                            {
-                                id: "SlackCLIAPI@1.30.0",
-                                name: "Slack",
-                                slug: "slack",
-                                images: {},
-                            },
-                        ],
-                    });
-                }
-                return Promise.resolve({ count: 0, results: [] });
-            }),
-        };
-        mockSdk = {
-            listApps: vi.fn().mockReturnValue({
-                items: vi.fn().mockReturnValue([
-                    {
-                        title: "Slack",
-                        key: "slack",
-                        current_implementation_id: "SlackCLIAPI@1.30.0",
-                        description: "Team communication platform",
-                    },
-                ][Symbol.iterator]()),
-            }),
-        };
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    const apiPlugin = () => ({
-        context: {
-            api: mockApiClient,
-        },
-    });
-    const listAppsMockPlugin = () => ({
-        listApps: mockSdk.listApps,
-        context: {
-            meta: {
-                listApps: {
-                    inputSchema: {},
-                },
-            },
-        },
-    });
-    function createTestSdk(options = {}) {
-        return createSdk(options)
-            .addPlugin(() => ({
-            context: {
-                options: {},
-            },
-        }))
-            .addPlugin(apiPlugin)
-            .addPlugin(eventEmissionPlugin)
-            .addPlugin(manifestPlugin);
-    }
-    describe("plugin initialization", () => {
-        it("should provide helper functions with direct manifest", () => {
-            const sdk = createTestSdk({ manifest: mockManifest });
-            const context = sdk.getContext();
-            expect(context.getVersionedImplementationId).toBeInstanceOf(Function);
-        });
-        it("should provide helper functions with manifestPath", async () => {
-            mockReadFile.mockResolvedValue(mockManifestContent);
-            const sdk = createTestSdk({ manifestPath: "manifest.json" });
-            const context = sdk.getContext();
-            expect(context.getVersionedImplementationId).toBeInstanceOf(Function);
-            // Verify file operations happen when functions are called
-            await context.getVersionedImplementationId("slack");
-            expect(mockResolve).toHaveBeenCalledWith("manifest.json");
-            expect(mockReadFile).toHaveBeenCalledWith("/resolved/manifest.json");
-        });
-        it("should provide helper functions when no manifest or path provided", () => {
-            const sdk = createTestSdk();
-            const context = sdk.getContext();
-            expect(context.getVersionedImplementationId).toBeInstanceOf(Function);
-            // Manifest functions are available even when no manifest is provided
-        });
-        it("should prioritize direct manifest over manifestPath", () => {
-            mockReadFile.mockResolvedValue('{"apps": {"other": {"implementationName": "Other", "version": "1.0.0"}}}');
-            createTestSdk({
-                manifest: mockManifest,
-                manifestPath: "manifest.json",
-            });
-            // Verify that direct manifest is used and file loading is not needed
-            expect(mockReadFile).not.toHaveBeenCalled();
-        });
-    });
-    describe("getVersionedImplementationId function", () => {
-        it("should return versioned implementation ID when app exists in manifest", async () => {
-            const sdk = createTestSdk({ manifest: mockManifest });
-            const context = sdk.getContext();
-            const result = await context.getVersionedImplementationId("slack");
-            expect(result).toBe("SlackCLIAPI@1.21.1");
-        });
-        it("should fetch and return versioned implementation ID when app not in manifest", async () => {
-            const sdk = createTestSdk();
-            const context = sdk.getContext();
-            const result = await context.getVersionedImplementationId("slack");
-            expect(result).toBe("SlackCLIAPI@1.30.0");
-        });
-        it("should return null when app does not exist", async () => {
-            mockSdk.listApps = vi.fn().mockReturnValue({
-                items: vi.fn().mockReturnValue([][Symbol.iterator]()),
-            });
-            const sdk = createTestSdk();
-            const context = sdk.getContext();
-            const result = await context.getVersionedImplementationId("nonexistent");
-            expect(result).toBeNull();
-        });
-    });
-    describe("manifest parsing", () => {
-        it("should parse valid manifest content", () => {
-            createTestSdk({ manifest: mockManifest });
-            // Verify manifest is parsed correctly for other functions to use
-        });
-        it("should handle manifest with missing version", () => {
-            const manifestWithoutVersion = {
-                apps: {
-                    slack: {
-                        implementationName: "SlackCLIAPI",
-                    },
-                },
-            };
-            createTestSdk({ manifest: manifestWithoutVersion });
-            // Verify manifest with missing version is handled correctly
-        });
-        it("should handle empty manifest", () => {
-            createTestSdk({ manifest: {} });
-            // Verify empty manifest is handled correctly
-        });
-    });
-    describe("file loading", () => {
-        it("should load manifest from file successfully", async () => {
-            mockReadFile.mockResolvedValue(mockManifestContent);
-            const sdk = createTestSdk({ manifestPath: "manifest.json" });
-            const context = sdk.getContext();
-            // Verify that file operations happen when functions are called
-            await context.getVersionedImplementationId("slack");
-            expect(mockResolve).toHaveBeenCalledWith("manifest.json");
-            expect(mockReadFile).toHaveBeenCalledWith("/resolved/manifest.json");
-        });
-        it("should silently return null when file does not exist (ENOENT)", async () => {
-            const enoentError = Object.assign(new Error("ENOENT: no such file"), {
-                code: "ENOENT",
-            });
-            mockReadFile.mockRejectedValue(enoentError);
-            const sdk = createTestSdk({ manifestPath: "nonexistent.json" });
-            const context = sdk.getContext();
-            // Trigger file loading by calling a function
-            await context.getVersionedImplementationId("slack");
-            // Verify no warning is logged when file simply doesn't exist
-            expect(console.warn).not.toHaveBeenCalled();
-        });
-        it("should silently return null when file does not exist (browser fallback)", async () => {
-            mockReadFile.mockRejectedValue(new Error("File not found: /some/path"));
-            const sdk = createTestSdk({ manifestPath: "nonexistent.json" });
-            const context = sdk.getContext();
-            // Trigger file loading by calling a function
-            await context.getVersionedImplementationId("slack");
-            // Verify no warning is logged when file simply doesn't exist
-            expect(console.warn).not.toHaveBeenCalled();
-        });
-        it("should handle file read errors gracefully", async () => {
-            mockReadFile.mockRejectedValue(new Error("Permission denied"));
-            const sdk = createTestSdk({ manifestPath: "protected.json" });
-            const context = sdk.getContext();
-            // Trigger file loading by calling a function
-            await context.getVersionedImplementationId("slack");
-            // Verify file loading errors (other than file not found) are logged
-            expect(console.warn).toHaveBeenCalledWith(expect.stringContaining("Failed to read manifest from protected.json"));
-        });
-        it("should handle invalid JSON gracefully", async () => {
-            mockReadFile.mockResolvedValue("invalid json content");
-            const sdk = createTestSdk({ manifestPath: "invalid.json" });
-            const context = sdk.getContext();
-            // Trigger file loading by calling a function
-            await context.getVersionedImplementationId("slack");
-            // Verify JSON parsing errors are handled gracefully
-            expect(console.warn).toHaveBeenCalledWith(expect.stringContaining("Failed to parse manifest from /resolved/invalid.json"), expect.any(SyntaxError));
-        });
-        it("should handle JSON without apps property", () => {
-            mockReadFile.mockResolvedValue('{"other": "data"}');
-            createTestSdk({ manifestPath: "no-apps.json" });
-            // Verify missing apps property is handled correctly
-        });
-        it("should handle JSON with invalid apps format", () => {
-            mockReadFile.mockResolvedValue('{"apps": "not an object"}');
-            createTestSdk({ manifestPath: "invalid-apps.json" });
-            // Verify invalid apps format is handled correctly
-        });
-    });
-    describe("integration with SDK", () => {
-        it("should work with createSdk", async () => {
-            const sdk = createSdk({ manifest: mockManifest })
-                .addPlugin(apiPlugin)
-                .addPlugin(listAppsMockPlugin)
-                .addPlugin(manifestPlugin);
-            const context = sdk.getContext();
-            // Verify that the manifest data is used correctly by other functions
-            const versionedId = await context.getVersionedImplementationId("slack");
-            expect(versionedId).toBe("SlackCLIAPI@1.21.1");
-        });
-    });
-    describe("findManifestEntry function", () => {
-        it("should find entry by direct key match", () => {
-            const manifest = {
-                apps: {
-                    slack: { implementationName: "SlackCLIAPI", version: "1.21.1" },
-                    gmail: { implementationName: "GmailCLIAPI", version: "2.0.0" },
-                },
-            };
-            const result = findManifestEntry({ appKey: "slack", manifest });
-            expect(result).toEqual([
-                "slack",
-                { implementationName: "SlackCLIAPI", version: "1.21.1" },
-            ]);
-        });
-        it("should find entry by implementation name match", () => {
-            const manifest = {
-                apps: {
-                    SlackCLIAPI: { implementationName: "SlackCLIAPI", version: "1.21.1" },
-                    GmailCLIAPI: { implementationName: "GmailCLIAPI", version: "2.0.0" },
-                },
-            };
-            const result = findManifestEntry({ appKey: "SlackCLIAPI", manifest });
-            expect(result).toEqual([
-                "SlackCLIAPI",
-                { implementationName: "SlackCLIAPI", version: "1.21.1" },
-            ]);
-        });
-        it("should find existing key when searching by implementation name", () => {
-            const manifest = {
-                apps: {
-                    SlackCLIAPI: { implementationName: "SlackCLIAPI", version: "1.21.1" },
-                },
-            };
-            // This is the key test: searching by implementation name should find existing entry
-            const result = findManifestEntry({ appKey: "SlackCLIAPI", manifest });
-            expect(result).toEqual([
-                "SlackCLIAPI",
-                { implementationName: "SlackCLIAPI", version: "1.21.1" },
-            ]);
-        });
-        it("should return null when no match found", () => {
-            const manifest = {
-                apps: {
-                    gmail: { implementationName: "GmailCLIAPI", version: "2.0.0" },
-                },
-            };
-            const result = findManifestEntry({ appKey: "slack", manifest });
-            expect(result).toBeNull();
-        });
-        it("should handle snake-cased slugs", () => {
-            const manifest = {
-                apps: {
-                    "google-sheets": {
-                        implementationName: "GoogleSheetsCLIAPI",
-                        version: "1.0.0",
-                    },
-                },
-            };
-            const result = findManifestEntry({ appKey: "google_sheets", manifest });
-            expect(result).toEqual([
-                "google-sheets",
-                { implementationName: "GoogleSheetsCLIAPI", version: "1.0.0" },
-            ]);
-        });
-        it("should NOT find entry when searching slug against implementation name key (current limitation)", () => {
-            const manifest = {
-                apps: {
-                    SlackCLIAPI: { implementationName: "SlackCLIAPI", version: "1.21.1" },
-                },
-            };
-            // This will fail - we search by "slack" but can't find "SlackCLIAPI" entry
-            // This is the core issue we need to solve
-            const result = findManifestEntry({ appKey: "slack", manifest });
-            expect(result).toBeNull(); // Current behavior - doesn't find it
-            // We need to fix this so it CAN find existing implementation name entries
-        });
-    });
-    describe("updateManifestEntry with slug-to-implementation matching", () => {
-        it("should find existing implementation name entry when input is slug", async () => {
-            // Mock existing manifest with implementation name as key
-            mockReadFile.mockResolvedValue(JSON.stringify({
-                apps: {
-                    SlackCLIAPI: {
-                        implementationName: "SlackCLIAPI",
-                        version: "1.21.1",
-                    },
-                },
-            }));
-            // Mock resolveAppKeys to resolve "slack" to "SlackCLIAPI"
-            mockResolveAppKeys.mockResolvedValue([
-                {
-                    slug: "slack",
-                    implementationName: "SlackCLIAPI",
-                    version: "1.30.0",
-                    lookupAppKey: "slack",
-                },
-            ]);
-            const sdk = createTestSdk();
-            const context = sdk.getContext();
-            // This should now find the existing "SlackCLIAPI" entry
-            const { key: manifestKey } = await context.updateManifestEntry({
-                appKey: "slack", // Input is slug
-                entry: { implementationName: "SlackCLIAPI", version: "1.30.0" },
-            });
-            // Should return the existing key, not create a new one
-            expect(manifestKey).toBe("SlackCLIAPI");
-        });
-    });
-    describe("resolveAppKeys function", () => {
-        it("should resolve slug to manifest entry even when manifest uses implementation name as key", async () => {
-            const manifest = {
-                apps: {
-                    SlackCLIAPI: { implementationName: "SlackCLIAPI", version: "1.21.1" },
-                },
-            };
-            // Mock API to return slack app data when looking up "slack"
-            mockApiClient.get = vi.fn().mockResolvedValue({
-                count: 1,
-                next: null,
-                previous: null,
-                results: [
-                    {
-                        id: "SlackCLIAPI@1.30.0",
-                        name: "Slack",
-                        slug: "slack",
-                        key: "SlackCLIAPI", // This is the implementation name
-                        version: "1.30.0",
-                    },
-                ],
-            });
-            // Test resolveAppKeys directly using the manifest plugin
-            const sdk = createSdk({ manifest })
-                .addPlugin(apiPlugin)
-                .addPlugin(manifestPlugin);
-            const context = sdk.getContext();
-            const resolved = await context.resolveAppKeys({ appKeys: ["slack"] });
-            // Should find the manifest entry and use its version (1.21.1) instead of latest (1.30.0)
-            expect(resolved).toHaveLength(1);
-            expect(resolved[0]).toEqual({
-                slug: "slack",
-                implementationName: "SlackCLIAPI",
-                version: "1.21.1", // Should use manifest version, not API version
-                lookupAppKey: "slack",
-            });
-        });
-        it("should fall back to API version when no manifest entry found", async () => {
-            const manifest = { apps: {} }; // Empty manifest
-            // Mock API to return slack app data
-            mockApiClient.get = vi.fn().mockResolvedValue({
-                count: 1,
-                next: null,
-                previous: null,
-                results: [
-                    {
-                        id: "SlackCLIAPI@1.30.0",
-                        name: "Slack",
-                        slug: "slack",
-                        key: "SlackCLIAPI",
-                        version: "1.30.0",
-                    },
-                ],
-            });
-            const sdk = createSdk({ manifest })
-                .addPlugin(apiPlugin)
-                .addPlugin(manifestPlugin);
-            const context = sdk.getContext();
-            const resolved = await context.resolveAppKeys({ appKeys: ["slack"] });
-            // Should use API version since no manifest entry found
-            expect(resolved).toHaveLength(1);
-            expect(resolved[0]).toEqual({
-                slug: "slack",
-                implementationName: "SlackCLIAPI",
-                version: "1.30.0", // Should use API version
-                lookupAppKey: "slack",
-            });
-        });
-        it("should always use version from input when specified (slug@version)", async () => {
-            const manifest = {
-                apps: {
-                    SlackCLIAPI: { implementationName: "SlackCLIAPI", version: "1.21.1" },
-                },
-            };
-            // Mock API to return slack app data
-            mockApiClient.get = vi.fn().mockResolvedValue({
-                count: 1,
-                next: null,
-                previous: null,
-                results: [
-                    {
-                        id: "SlackCLIAPI@1.30.0",
-                        name: "Slack",
-                        slug: "slack",
-                        key: "SlackCLIAPI",
-                        version: "1.30.0",
-                    },
-                ],
-            });
-            const sdk = createSdk({ manifest })
-                .addPlugin(apiPlugin)
-                .addPlugin(manifestPlugin);
-            const context = sdk.getContext();
-            // Input version should take precedence over both manifest (1.21.1) and API (1.30.0)
-            const resolved = await context.resolveAppKeys({
-                appKeys: ["slack@1.2.3"],
-            });
-            expect(resolved).toHaveLength(1);
-            expect(resolved[0]).toEqual({
-                slug: "slack",
-                implementationName: "SlackCLIAPI",
-                version: "1.2.3", // Should use input version, not manifest or API
-                lookupAppKey: "slack",
-            });
-        });
-        it("should always use version from input when specified (implementationName@version)", async () => {
-            const manifest = {
-                apps: {
-                    SlackCLIAPI: { implementationName: "SlackCLIAPI", version: "1.21.1" },
-                },
-            };
-            const sdk = createSdk({ manifest })
-                .addPlugin(apiPlugin)
-                .addPlugin(manifestPlugin);
-            const context = sdk.getContext();
-            // Input version should take precedence over manifest version
-            const resolved = await context.resolveAppKeys({
-                appKeys: ["SlackCLIAPI@1.2.3"],
-            });
-            expect(resolved).toHaveLength(1);
-            expect(resolved[0]).toEqual({
-                implementationName: "SlackCLIAPI",
-                version: "1.2.3", // Should use input version, not manifest version
-                lookupAppKey: "SlackCLIAPI",
-            });
-        });
-    });
-});
-describe("readManifestFromFile", () => {
-    const mockManifestContent = JSON.stringify({
-        apps: {
-            slack: {
-                implementationName: "SlackCLIAPI",
-                version: "1.21.1",
-            },
-            "google-sheets": {
-                implementationName: "GoogleSheetsCLIAPI",
-                version: "2.0.0",
-            },
-        },
-    });
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it("should read and parse manifest from file", async () => {
-        mockReadFile.mockResolvedValue(mockManifestContent);
-        const result = await readManifestFromFile("manifest.json");
-        expect(mockResolve).toHaveBeenCalledWith("manifest.json");
-        expect(mockReadFile).toHaveBeenCalledWith("/resolved/manifest.json");
-        expect(result).toEqual({
-            apps: {
-                slack: {
-                    implementationName: "SlackCLIAPI",
-                    version: "1.21.1",
-                },
-                "google-sheets": {
-                    implementationName: "GoogleSheetsCLIAPI",
-                    version: "2.0.0",
-                },
-            },
-        });
-    });
-    it("should return null without warning when file does not exist (ENOENT)", async () => {
-        vi.spyOn(console, "warn").mockImplementation(() => { });
-        const enoentError = Object.assign(new Error("ENOENT: no such file"), {
-            code: "ENOENT",
-        });
-        mockReadFile.mockRejectedValue(enoentError);
-        const result = await readManifestFromFile("nonexistent.json");
-        expect(result).toBeNull();
-        expect(console.warn).not.toHaveBeenCalled();
-    });
-    it("should return null without warning when file does not exist (browser fallback)", async () => {
-        vi.spyOn(console, "warn").mockImplementation(() => { });
-        mockReadFile.mockRejectedValue(new Error("File not found: /some/path"));
-        const result = await readManifestFromFile("nonexistent.json");
-        expect(result).toBeNull();
-        expect(console.warn).not.toHaveBeenCalled();
-    });
-    it("should handle file read errors with warning", async () => {
-        vi.spyOn(console, "warn").mockImplementation(() => { });
-        mockReadFile.mockRejectedValue(new Error("Permission denied"));
-        const result = await readManifestFromFile("protected.json");
-        expect(result).toBeNull();
-        expect(console.warn).toHaveBeenCalledWith(expect.stringContaining("Failed to read manifest from protected.json"));
-    });
-    it("should handle invalid JSON content", async () => {
-        mockReadFile.mockResolvedValue("invalid json");
-        const result = await readManifestFromFile("invalid.json");
-        expect(result).toBeNull();
-    });
-    describe("getPreferredManifestEntryKey", () => {
-        let mockApi;
-        beforeEach(() => {
-            mockApi = {
-                get: vi.fn(),
-            };
-        });
-        it("should prefer slug when available", async () => {
-            const result = await getPreferredManifestEntryKey({
-                appKey: "slack",
-                api: mockApi,
-            });
-            expect(result).toBe("slack");
-        });
-        it("should look up slug for implementation name", async () => {
-            // Mock API response for implementation name lookup
-            mockApi.get = vi.fn().mockResolvedValueOnce({
-                results: [
-                    {
-                        key: "SlackCLIAPI",
-                        slug: "slack",
-                        version: "1.0.0",
-                        current_implementation_id: "SlackCLIAPI@1.0.0",
-                    },
-                ],
-                next: null,
-            });
-            const result = await getPreferredManifestEntryKey({
-                appKey: "SlackCLIAPI",
-                api: mockApi,
-            });
-            expect(result).toBe("slack");
-            expect(mockApi.get).toHaveBeenCalledWith("/zapier/api/v4/implementations-meta/lookup/", {
-                searchParams: { selected_apis: "SlackCLIAPI" },
-            });
-        });
-        it("should fall back to implementation name if slug lookup fails", async () => {
-            // Mock API to return empty results
-            mockApi.get = vi.fn().mockResolvedValueOnce({
-                results: [],
-                next: null,
-            });
-            const result = await getPreferredManifestEntryKey({
-                appKey: "SlackCLIAPI",
-                api: mockApi,
-            });
-            expect(result).toBe("SlackCLIAPI");
-        });
-        it("should fall back to original key if no slug or implementation name", async () => {
-            const result = await getPreferredManifestEntryKey({
-                appKey: "some-random-key",
-                api: mockApi,
-            });
-            expect(result).toBe("some-random-key");
-        });
-    });
-    describe("Action management", () => {
-        const mockManifest = {
-            apps: {
-                slack: {
-                    implementationName: "SlackCLIAPI",
-                    version: "1.21.1",
-                },
-            },
-        };
-        let mockApiClient;
-        beforeEach(() => {
-            vi.clearAllMocks();
-            vi.spyOn(console, "warn").mockImplementation(() => { });
-            mockApiClient = {
-                get: vi.fn(),
-            };
-        });
-        afterEach(() => {
-            vi.restoreAllMocks();
-        });
-        const apiPlugin = () => ({
-            context: {
-                api: mockApiClient,
-            },
-        });
-        function createTestSdk(options = {}) {
-            return createSdk(options).addPlugin(apiPlugin).addPlugin(manifestPlugin);
-        }
-        describe("findActionEntry", () => {
-            it("should find an existing action by name", () => {
-                const manifest = {
-                    apps: mockManifest.apps,
-                    actions: {
-                        "weekly-report": {
-                            appKey: "slack",
-                            actionKey: "post_message",
-                            actionType: "write",
-                            authenticationId: 123,
-                            inputs: { channel: "#general" },
-                            schema: {},
-                            createdAt: "2025-11-18T12:00:00.000Z",
-                        },
-                    },
-                };
-                const sdk = createTestSdk({ manifest });
-                const context = sdk.getContext();
-                const action = context.findActionEntry({
-                    name: "weekly-report",
-                    manifest,
-                });
-                expect(action).toEqual({
-                    appKey: "slack",
-                    actionKey: "post_message",
-                    actionType: "write",
-                    authenticationId: 123,
-                    inputs: { channel: "#general" },
-                    schema: {},
-                    createdAt: "2025-11-18T12:00:00.000Z",
-                });
-            });
-            it("should return null for non-existent action", () => {
-                const manifest = {
-                    apps: mockManifest.apps,
-                    actions: {},
-                };
-                const sdk = createTestSdk({ manifest });
-                const context = sdk.getContext();
-                const action = context.findActionEntry({
-                    name: "non-existent",
-                    manifest,
-                });
-                expect(action).toBeNull();
-            });
-            it("should return null when manifest has no actions section", () => {
-                const manifest = {
-                    apps: mockManifest.apps,
-                };
-                const sdk = createTestSdk({ manifest });
-                const context = sdk.getContext();
-                const action = context.findActionEntry({
-                    name: "any-action",
-                    manifest,
-                });
-                expect(action).toBeNull();
-            });
-        });
-        describe("hasActionEntry", () => {
-            it("should return true for existing action", () => {
-                const manifest = {
-                    apps: mockManifest.apps,
-                    actions: {
-                        "weekly-report": {
-                            appKey: "slack",
-                            actionKey: "post_message",
-                            actionType: "write",
-                            authenticationId: 123,
-                            inputs: {},
-                            schema: {},
-                            createdAt: "2025-11-18T12:00:00.000Z",
-                        },
-                    },
-                };
-                const sdk = createTestSdk({ manifest });
-                const context = sdk.getContext();
-                const exists = context.hasActionEntry({
-                    name: "weekly-report",
-                    manifest,
-                });
-                expect(exists).toBe(true);
-            });
-            it("should return false for non-existent action", () => {
-                const manifest = {
-                    apps: mockManifest.apps,
-                    actions: {},
-                };
-                const sdk = createTestSdk({ manifest });
-                const context = sdk.getContext();
-                const exists = context.hasActionEntry({
-                    name: "non-existent",
-                    manifest,
-                });
-                expect(exists).toBe(false);
-            });
-            it("should return false when manifest has no actions section", () => {
-                const manifest = {
-                    apps: mockManifest.apps,
-                };
-                const sdk = createTestSdk({ manifest });
-                const context = sdk.getContext();
-                const exists = context.hasActionEntry({ name: "any-action", manifest });
-                expect(exists).toBe(false);
-            });
-        });
-        describe("listActionEntries", () => {
-            it("should return all actions as [name, entry] tuples", async () => {
-                const mockManifestContent = JSON.stringify({
-                    apps: mockManifest.apps,
-                    actions: {
-                        "weekly-report": {
-                            appKey: "slack",
-                            actionKey: "post_message",
-                            actionType: "write",
-                            authenticationId: 123,
-                            inputs: { channel: "#general" },
-                            schema: {},
-                            createdAt: "2025-11-18T12:00:00.000Z",
-                        },
-                        "daily-summary": {
-                            appKey: "slack",
-                            actionKey: "post_message",
-                            actionType: "write",
-                            authenticationId: 123,
-                            inputs: { channel: "#daily" },
-                            schema: {},
-                            createdAt: "2025-11-18T13:00:00.000Z",
-                        },
-                    },
-                });
-                mockReadFile.mockResolvedValue(mockManifestContent);
-                const sdk = createTestSdk({ manifestPath: ".zapierrc" });
-                const context = sdk.getContext();
-                const actions = await context.listActionEntries({
-                    configPath: ".zapierrc",
-                });
-                expect(actions).toHaveLength(2);
-                expect(actions).toEqual([
-                    [
-                        "weekly-report",
-                        {
-                            appKey: "slack",
-                            actionKey: "post_message",
-                            actionType: "write",
-                            authenticationId: 123,
-                            inputs: { channel: "#general" },
-                            schema: {},
-                            createdAt: "2025-11-18T12:00:00.000Z",
-                        },
-                    ],
-                    [
-                        "daily-summary",
-                        {
-                            appKey: "slack",
-                            actionKey: "post_message",
-                            actionType: "write",
-                            authenticationId: 123,
-                            inputs: { channel: "#daily" },
-                            schema: {},
-                            createdAt: "2025-11-18T13:00:00.000Z",
-                        },
-                    ],
-                ]);
-            });
-            it("should return empty array when no actions exist", async () => {
-                const mockManifestContent = JSON.stringify({
-                    apps: mockManifest.apps,
-                });
-                mockReadFile.mockResolvedValue(mockManifestContent);
-                const sdk = createTestSdk({ manifestPath: ".zapierrc" });
-                const context = sdk.getContext();
-                const actions = await context.listActionEntries({
-                    configPath: ".zapierrc",
-                });
-                expect(actions).toEqual([]);
-            });
-            it("should use default configPath when not provided", async () => {
-                const mockManifestContent = JSON.stringify({
-                    apps: mockManifest.apps,
-                    actions: {},
-                });
-                mockReadFile.mockResolvedValue(mockManifestContent);
-                const sdk = createTestSdk();
-                const context = sdk.getContext();
-                await context.listActionEntries();
-                expect(mockResolve).toHaveBeenCalledWith(".zapierrc");
-            });
-        });
-        describe("addActionEntry", () => {
-            it("should successfully add a new action", async () => {
-                const mockManifestContent = JSON.stringify({
-                    apps: mockManifest.apps,
-                });
-                mockReadFile.mockResolvedValue(mockManifestContent);
-                const sdk = createTestSdk({ manifestPath: ".zapierrc" });
-                const context = sdk.getContext();
-                const entry = {
-                    appKey: "slack",
-                    actionKey: "post_message",
-                    actionType: "write",
-                    authenticationId: 123,
-                    inputs: { channel: "#general" },
-                    schema: { type: "object" },
-                    createdAt: "2025-11-18T12:00:00.000Z",
-                };
-                const { name, entry: returnedEntry, manifest: updatedManifest, } = await context.addActionEntry({
-                    name: "weekly-report",
-                    entry,
-                    configPath: ".zapierrc",
-                });
-                expect(name).toBe("weekly-report");
-                expect(returnedEntry).toEqual(entry);
-                expect(updatedManifest.actions).toEqual({
-                    "weekly-report": entry,
-                });
-            });
-            it("should throw error when action name already exists", async () => {
-                const mockManifestContent = JSON.stringify({
-                    apps: mockManifest.apps,
-                    actions: {
-                        "weekly-report": {
-                            appKey: "slack",
-                            actionKey: "post_message",
-                            actionType: "write",
-                            authenticationId: 123,
-                            inputs: {},
-                            schema: {},
-                            createdAt: "2025-11-18T12:00:00.000Z",
-                        },
-                    },
-                });
-                mockReadFile.mockResolvedValue(mockManifestContent);
-                const sdk = createTestSdk({ manifestPath: ".zapierrc" });
-                const context = sdk.getContext();
-                const entry = {
-                    appKey: "slack",
-                    actionKey: "post_message",
-                    actionType: "write",
-                    authenticationId: 123,
-                    inputs: {},
-                    schema: {},
-                    createdAt: "2025-11-18T13:00:00.000Z",
-                };
-                await expect(context.addActionEntry({
-                    name: "weekly-report",
-                    entry,
-                    configPath: ".zapierrc",
-                })).rejects.toThrow('Action "weekly-report" already exists. Please choose a different name or remove the existing action first.');
-            });
-            it("should allow duplicate name with skipWrite option", async () => {
-                const mockManifestContent = JSON.stringify({
-                    apps: mockManifest.apps,
-                    actions: {
-                        "weekly-report": {
-                            appKey: "slack",
-                            actionKey: "post_message",
-                            actionType: "write",
-                            authenticationId: 123,
-                            inputs: {},
-                            schema: {},
-                            createdAt: "2025-11-18T12:00:00.000Z",
-                        },
-                    },
-                });
-                mockReadFile.mockResolvedValue(mockManifestContent);
-                const sdk = createTestSdk({ manifestPath: ".zapierrc" });
-                const context = sdk.getContext();
-                const entry = {
-                    appKey: "slack",
-                    actionKey: "post_message",
-                    actionType: "write",
-                    authenticationId: 456,
-                    inputs: {},
-                    schema: {},
-                    createdAt: "2025-11-18T13:00:00.000Z",
-                };
-                const { name, entry: returnedEntry } = await context.addActionEntry({
-                    name: "weekly-report",
-                    entry,
-                    configPath: ".zapierrc",
-                    skipWrite: true,
-                });
-                expect(name).toBe("weekly-report");
-                expect(returnedEntry).toEqual(entry);
-            });
-            it("should create actions section if it doesn't exist", async () => {
-                const mockManifestContent = JSON.stringify({
-                    apps: mockManifest.apps,
-                });
-                mockReadFile.mockResolvedValue(mockManifestContent);
-                const sdk = createTestSdk({ manifestPath: ".zapierrc" });
-                const context = sdk.getContext();
-                const entry = {
-                    appKey: "slack",
-                    actionKey: "post_message",
-                    actionType: "write",
-                    authenticationId: 123,
-                    inputs: {},
-                    schema: {},
-                    createdAt: "2025-11-18T12:00:00.000Z",
-                };
-                const { manifest: updatedManifest } = await context.addActionEntry({
-                    name: "first-action",
-                    entry,
-                    configPath: ".zapierrc",
-                });
-                expect(updatedManifest.actions).toBeDefined();
-                expect(updatedManifest.actions).toEqual({
-                    "first-action": entry,
-                });
-            });
-        });
-        describe("deleteActionEntry", () => {
-            it("should successfully delete an existing action", async () => {
-                const mockManifestContent = JSON.stringify({
-                    apps: mockManifest.apps,
-                    actions: {
-                        "weekly-report": {
-                            appKey: "slack",
-                            actionKey: "post_message",
-                            actionType: "write",
-                            authenticationId: 123,
-                            inputs: {},
-                            schema: {},
-                            createdAt: "2025-11-18T12:00:00.000Z",
-                        },
-                        "daily-summary": {
-                            appKey: "slack",
-                            actionKey: "post_message",
-                            actionType: "write",
-                            authenticationId: 123,
-                            inputs: {},
-                            schema: {},
-                            createdAt: "2025-11-18T13:00:00.000Z",
-                        },
-                    },
-                });
-                mockReadFile.mockResolvedValue(mockManifestContent);
-                const sdk = createTestSdk({ manifestPath: ".zapierrc" });
-                const context = sdk.getContext();
-                const updatedManifest = await context.deleteActionEntry({
-                    name: "weekly-report",
-                    configPath: ".zapierrc",
-                });
-                expect(updatedManifest.actions).toEqual({
-                    "daily-summary": {
-                        appKey: "slack",
-                        actionKey: "post_message",
-                        actionType: "write",
-                        authenticationId: 123,
-                        inputs: {},
-                        schema: {},
-                        createdAt: "2025-11-18T13:00:00.000Z",
-                    },
-                });
-                expect(updatedManifest.actions?.["weekly-report"]).toBeUndefined();
-            });
-            it("should throw error when action does not exist", async () => {
-                const mockManifestContent = JSON.stringify({
-                    apps: mockManifest.apps,
-                    actions: {},
-                });
-                mockReadFile.mockResolvedValue(mockManifestContent);
-                const sdk = createTestSdk({ manifestPath: ".zapierrc" });
-                const context = sdk.getContext();
-                await expect(context.deleteActionEntry({
-                    name: "non-existent",
-                    configPath: ".zapierrc",
-                })).rejects.toThrow('Action "non-existent" does not exist.');
-            });
-            it("should work with skipWrite option", async () => {
-                const mockManifestContent = JSON.stringify({
-                    apps: mockManifest.apps,
-                    actions: {
-                        "weekly-report": {
-                            appKey: "slack",
-                            actionKey: "post_message",
-                            actionType: "write",
-                            authenticationId: 123,
-                            inputs: {},
-                            schema: {},
-                            createdAt: "2025-11-18T12:00:00.000Z",
-                        },
-                    },
-                });
-                mockReadFile.mockResolvedValue(mockManifestContent);
-                const sdk = createTestSdk({ manifestPath: ".zapierrc" });
-                const context = sdk.getContext();
-                const updatedManifest = await context.deleteActionEntry({
-                    name: "weekly-report",
-                    configPath: ".zapierrc",
-                    skipWrite: true,
-                });
-                expect(updatedManifest.actions).toEqual({});
-            });
-            it("should handle deleting the last action", async () => {
-                const mockManifestContent = JSON.stringify({
-                    apps: mockManifest.apps,
-                    actions: {
-                        "only-action": {
-                            appKey: "slack",
-                            actionKey: "post_message",
-                            actionType: "write",
-                            authenticationId: 123,
-                            inputs: {},
-                            schema: {},
-                            createdAt: "2025-11-18T12:00:00.000Z",
-                        },
-                    },
-                });
-                mockReadFile.mockResolvedValue(mockManifestContent);
-                const sdk = createTestSdk({ manifestPath: ".zapierrc" });
-                const context = sdk.getContext();
-                const updatedManifest = await context.deleteActionEntry({
-                    name: "only-action",
-                    configPath: ".zapierrc",
-                });
-                expect(updatedManifest.actions).toEqual({});
-            });
-        });
-        describe("action CRUD integration", () => {
-            it("should support full CRUD workflow", async () => {
-                const mockManifestContent = JSON.stringify({
-                    apps: mockManifest.apps,
-                });
-                mockReadFile.mockResolvedValue(mockManifestContent);
-                const sdk = createTestSdk({ manifestPath: ".zapierrc" });
-                const context = sdk.getContext();
-                // Create first action
-                const entry1 = {
-                    appKey: "slack",
-                    actionKey: "post_message",
-                    actionType: "write",
-                    authenticationId: 123,
-                    inputs: { channel: "#general" },
-                    schema: {},
-                    createdAt: "2025-11-18T12:00:00.000Z",
-                };
-                const { manifest: manifest1 } = await context.addActionEntry({
-                    name: "action-1",
-                    entry: entry1,
-                    skipWrite: true,
-                });
-                // Create second action
-                const entry2 = {
-                    appKey: "slack",
-                    actionKey: "post_message",
-                    actionType: "write",
-                    authenticationId: 123,
-                    inputs: { channel: "#daily" },
-                    schema: {},
-                    createdAt: "2025-11-18T13:00:00.000Z",
-                };
-                const { manifest: manifest2 } = await context.addActionEntry({
-                    name: "action-2",
-                    entry: entry2,
-                    manifest: manifest1,
-                    skipWrite: true,
-                });
-                // Verify both actions exist
-                expect(context.hasActionEntry({ name: "action-1", manifest: manifest2 })).toBe(true);
-                expect(context.hasActionEntry({ name: "action-2", manifest: manifest2 })).toBe(true);
-                // Find action
-                const foundAction = context.findActionEntry({
-                    name: "action-1",
-                    manifest: manifest2,
-                });
-                expect(foundAction).toEqual(entry1);
-                // List actions
-                mockReadFile.mockResolvedValue(JSON.stringify(manifest2));
-                const actions = await context.listActionEntries({
-                    configPath: ".zapierrc",
-                });
-                expect(actions).toHaveLength(2);
-                // Delete action
-                const manifest3 = await context.deleteActionEntry({
-                    name: "action-1",
-                    skipWrite: true,
-                });
-                expect(context.hasActionEntry({ name: "action-1", manifest: manifest3 })).toBe(false);
-                expect(context.hasActionEntry({ name: "action-2", manifest: manifest3 })).toBe(true);
-            });
-        });
-    });
-});