@zapier/zapier-sdk 0.15.1 → 0.15.3

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

@@ -1,4 +1,4 @@
-import type { GetVersionedImplementationId, Manifest, ManifestEntry, ManifestPluginOptionsSchema, ResolveAppKeys } from "./schemas";
+import type { GetVersionedImplementationId, Manifest, ManifestEntry, ManifestPluginOptionsSchema, ResolveAppKeys, ActionEntry } from "./schemas";
 import type { Plugin } from "../../types/plugin";
 import type { z } from "zod";
 import type { ApiClient } from "../../api";
@@ -10,11 +10,50 @@ export interface UpdateManifestEntryOptions {
     skipWrite?: boolean;
     manifest?: Manifest;
 }
+export interface UpdateManifestEntryResult {
+    key: string;
+    entry: ManifestEntry;
+    manifest: Manifest;
+}
+export interface AddActionEntryOptions {
+    name: string;
+    entry: ActionEntry;
+    configPath?: string;
+    skipWrite?: boolean;
+    manifest?: Manifest;
+}
+export interface AddActionEntryResult {
+    name: string;
+    entry: ActionEntry;
+    manifest: Manifest;
+}
 export interface ManifestPluginProvides {
     context: {
         getVersionedImplementationId: GetVersionedImplementationId;
         resolveAppKeys: ResolveAppKeys;
-        updateManifestEntry: (options: UpdateManifestEntryOptions) => Promise<[string, ManifestEntry, Manifest]>;
+        updateManifestEntry: (options: UpdateManifestEntryOptions) => Promise<UpdateManifestEntryResult>;
+        addActionEntry: (options: AddActionEntryOptions) => Promise<AddActionEntryResult>;
+        findActionEntry: (options: {
+            name: string;
+            manifest: Manifest;
+        }) => ActionEntry | null;
+        listActionEntries: (options?: {
+            configPath?: string;
+        }) => Promise<Array<[string, ActionEntry]>>;
+        deleteActionEntry: (options: {
+            name: string;
+            configPath?: string;
+            skipWrite?: boolean;
+        }) => Promise<Manifest>;
+        hasActionEntry: (options: {
+            name: string;
+            manifest: Manifest;
+        }) => boolean;
+        findManifestEntry: (options: {
+            appKey: string;
+            manifest: Manifest;
+        }) => [string, ManifestEntry] | null;
+        readManifestFromFile: (filePath: string) => Promise<Manifest | null>;
     };
 }
 /**
@@ -38,7 +77,7 @@ export declare function findManifestEntry({ appKey, manifest, }: {
     manifest: Manifest;
 }): [string, ManifestEntry] | null;
 export { DEFAULT_CONFIG_PATH } from "./schemas";
-export type { ManifestEntry, Manifest } from "./schemas";
+export type { ManifestEntry, Manifest, ActionEntry } from "./schemas";
 export declare const manifestPlugin: Plugin<{}, // no SDK dependencies
 {
     api: ApiClient;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/manifest/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,4BAA4B,EAC5B,QAAQ,EACR,aAAa,EACb,2BAA2B,EAC3B,cAAc,EACf,MAAM,WAAW,CAAC;AAEnB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAgB3C,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,MAAM,WAAW,0BAA0B;IACzC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,aAAa,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB;AAED,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE;QACP,4BAA4B,EAAE,4BAA4B,CAAC;QAC3D,cAAc,EAAE,cAAc,CAAC;QAC/B,mBAAmB,EAAE,CACnB,OAAO,EAAE,0BAA0B,KAChC,OAAO,CAAC,CAAC,MAAM,EAAE,aAAa,EAAE,QAAQ,CAAC,CAAC,CAAC;KACjD,CAAC;CACH;AA2BD;;;GAGG;AACH,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAU1B;AAcD;;;GAGG;AACH,wBAAsB,4BAA4B,CAAC,EACjD,MAAM,EACN,GAAG,GACJ,EAAE;IACD,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,SAAS,CAAC;CAChB,GAAG,OAAO,CAAC,MAAM,CAAC,CAkClB;AAoCD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,MAAM,EACN,QAAQ,GACT,EAAE;IACD,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,QAAQ,CAAC;CACpB,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,GAAG,IAAI,CAyBjC;AA8GD,OAAO,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAChD,YAAY,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAEzD,eAAO,MAAM,cAAc,EAAE,MAAM,CACjC,EAAE,EAAE,sBAAsB;AAC1B;IAAE,GAAG,EAAE,SAAS,CAAA;CAAE,EAClB,sBAAsB,CAgIvB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/manifest/index.ts"],"names":[],"mappings":"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"}

package/dist/plugins/manifest/index.js

@@ -293,7 +293,67 @@ export const manifestPlugin = (params) => {
             // Clear the cached manifest so it gets reloaded with the new data
             resolvedManifest = undefined;
         }
-        return [manifestKey, entry, updatedManifest];
+        return {
+            key: manifestKey,
+            entry,
+            manifest: updatedManifest,
+        };
+    };
+    const addActionEntry = async (options) => {
+        const { name, entry, configPath = DEFAULT_CONFIG_PATH, skipWrite = false, manifest: inputManifest, } = options;
+        // Use provided manifest or read from file
+        const manifest = inputManifest ||
+            (await readManifestFromFile(configPath)) || { apps: {} };
+        // Ensure actions exists
+        const actions = manifest.actions || {};
+        // Validate uniqueness - if action with this name already exists, throw error
+        if (actions[name] && !skipWrite) {
+            throw new Error(`Action "${name}" already exists. Please choose a different name or remove the existing action first.`);
+        }
+        const updatedManifest = {
+            ...manifest,
+            actions: {
+                ...actions,
+                [name]: entry,
+            },
+        };
+        // Conditionally write to file
+        if (!skipWrite) {
+            await writeManifestToFile(updatedManifest, configPath);
+            // Clear the cached manifest so it gets reloaded with the new data
+            resolvedManifest = undefined;
+        }
+        return {
+            name,
+            entry,
+            manifest: updatedManifest,
+        };
+    };
+    const findActionEntry = ({ name, manifest, }) => {
+        return manifest.actions?.[name] || null;
+    };
+    const listActionEntries = async ({ configPath = DEFAULT_CONFIG_PATH, } = {}) => {
+        const manifest = (await readManifestFromFile(configPath)) || { apps: {} };
+        return Object.entries(manifest.actions || {});
+    };
+    const deleteActionEntry = async ({ name, configPath = DEFAULT_CONFIG_PATH, skipWrite = false, }) => {
+        const manifest = (await readManifestFromFile(configPath)) || { apps: {} };
+        if (!manifest.actions?.[name]) {
+            throw new Error(`Action "${name}" does not exist.`);
+        }
+        const { [name]: removed, ...remainingActions } = manifest.actions;
+        const updatedManifest = {
+            ...manifest,
+            actions: remainingActions,
+        };
+        if (!skipWrite) {
+            await writeManifestToFile(updatedManifest, configPath);
+            resolvedManifest = undefined;
+        }
+        return updatedManifest;
+    };
+    const hasActionEntry = ({ name, manifest, }) => {
+        return !!manifest.actions?.[name];
     };
     return {
         context: {
@@ -304,6 +364,13 @@ export const manifestPlugin = (params) => {
                 manifest: (await getResolvedManifest()) ?? { apps: {} },
             }),
             updateManifestEntry,
+            addActionEntry,
+            findActionEntry,
+            listActionEntries,
+            deleteActionEntry,
+            hasActionEntry,
+            findManifestEntry,
+            readManifestFromFile,
         },
     };
 };

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

@@ -379,7 +379,7 @@ describe("manifestPlugin", () => {
             const sdk = createTestSdk();
             const context = sdk.getContext();
             // This should now find the existing "SlackCLIAPI" entry
-            const [manifestKey] = await context.updateManifestEntry({
+            const { key: manifestKey } = await context.updateManifestEntry({
                 appKey: "slack", // Input is slug
                 entry: { implementationName: "SlackCLIAPI", version: "1.30.0" },
             });
@@ -615,4 +615,516 @@ describe("readManifestFromFile", () => {
             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);
+            });
+        });
+    });
 });