@zapier/zapier-sdk 0.15.2 → 0.15.4

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);
+            });
+        });
+    });
 });

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

@@ -8,15 +8,45 @@ export type ManifestEntry = {
 };
 export type GetVersionedImplementationId = (appKey: string) => Promise<string | null>;
 export type GetImplementation = (appKey: string) => Promise<AppItem | null>;
+/**
+ * Action entry for storing saved action configurations
+ * The key in the actions record IS the user-provided name
+ */
+export declare const ActionEntrySchema: z.ZodObject<{
+    appKey: z.ZodString;
+    actionKey: z.ZodString;
+    actionType: z.ZodString;
+    authenticationId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    createdAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    schema: Record<string, unknown>;
+    appKey: string;
+    actionKey: string;
+    actionType: string;
+    createdAt: string;
+    authenticationId?: number | null | undefined;
+    inputs?: Record<string, unknown> | undefined;
+}, {
+    schema: Record<string, unknown>;
+    appKey: string;
+    actionKey: string;
+    actionType: string;
+    createdAt: string;
+    authenticationId?: number | null | undefined;
+    inputs?: Record<string, unknown> | undefined;
+}>;
+export type ActionEntry = z.infer<typeof ActionEntrySchema>;
 export type Manifest = {
     apps: Record<string, ManifestEntry>;
+    actions?: Record<string, ActionEntry>;
 };
 export type ResolveAppKeys = ({ appKeys, }: {
     appKeys: string[];
 }) => Promise<ResolvedAppLocator[]>;
 /**
- * Manifest schema for version locking
- * Maps app keys to their locked version information
+ * Manifest schema for version locking and saved action configurations
  */
 export declare const ManifestSchema: z.ZodObject<{
     apps: z.ZodRecord<z.ZodString, z.ZodObject<{
@@ -29,16 +59,59 @@ export declare const ManifestSchema: z.ZodObject<{
         version: string;
         implementationName: string;
     }>>;
+    actions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        appKey: z.ZodString;
+        actionKey: z.ZodString;
+        actionType: z.ZodString;
+        authenticationId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        createdAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        schema: Record<string, unknown>;
+        appKey: string;
+        actionKey: string;
+        actionType: string;
+        createdAt: string;
+        authenticationId?: number | null | undefined;
+        inputs?: Record<string, unknown> | undefined;
+    }, {
+        schema: Record<string, unknown>;
+        appKey: string;
+        actionKey: string;
+        actionType: string;
+        createdAt: string;
+        authenticationId?: number | null | undefined;
+        inputs?: Record<string, unknown> | undefined;
+    }>>>;
 }, "strip", z.ZodTypeAny, {
     apps: Record<string, {
         version: string;
         implementationName: string;
     }>;
+    actions?: Record<string, {
+        schema: Record<string, unknown>;
+        appKey: string;
+        actionKey: string;
+        actionType: string;
+        createdAt: string;
+        authenticationId?: number | null | undefined;
+        inputs?: Record<string, unknown> | undefined;
+    }> | undefined;
 }, {
     apps: Record<string, {
         version: string;
         implementationName: string;
     }>;
+    actions?: Record<string, {
+        schema: Record<string, unknown>;
+        appKey: string;
+        actionKey: string;
+        actionType: string;
+        createdAt: string;
+        authenticationId?: number | null | undefined;
+        inputs?: Record<string, unknown> | undefined;
+    }> | undefined;
 }>;
 export declare const ManifestPluginOptionsSchema: z.ZodObject<{
     manifestPath: z.ZodOptional<z.ZodString>;

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

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/manifest/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACnE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAElD,eAAO,MAAM,mBAAmB,EAAG,WAAoB,CAAC;AAExD,MAAM,MAAM,aAAa,GAAG;IAC1B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG,CACzC,MAAM,EAAE,MAAM,KACX,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;AAE5B,MAAM,MAAM,iBAAiB,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC;AAE5E,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;CACrC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,EAC5B,OAAO,GACR,EAAE;IACD,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,KAAK,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAAC;AAEpC;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;EAcoC,CAAC;AAEhE,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;EAYtC,CAAC"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/manifest/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACnE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAElD,eAAO,MAAM,mBAAmB,EAAG,WAAoB,CAAC;AAExD,MAAM,MAAM,aAAa,GAAG;IAC1B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG,CACzC,MAAM,EAAE,MAAM,KACX,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;AAE5B,MAAM,MAAM,iBAAiB,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC;AAE5E;;;GAGG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;EAkB5B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IACpC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,EAC5B,OAAO,GACR,EAAE;IACD,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,KAAK,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAAC;AAEpC;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkB8C,CAAC;AAE1E,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;EAYtC,CAAC"}

package/dist/plugins/manifest/schemas.js

@@ -1,8 +1,28 @@
 import { z } from "zod";
 export const DEFAULT_CONFIG_PATH = ".zapierrc";
 /**
- * Manifest schema for version locking
- * Maps app keys to their locked version information
+ * Action entry for storing saved action configurations
+ * The key in the actions record IS the user-provided name
+ */
+export const ActionEntrySchema = z.object({
+    appKey: z.string().describe("App key (slug or implementation name)"),
+    actionKey: z.string().describe("Action key identifier"),
+    actionType: z
+        .string()
+        .describe("Action type (e.g., 'read', 'write', 'search')"),
+    authenticationId: z
+        .number()
+        .nullable()
+        .optional()
+        .describe("Authentication ID used"),
+    inputs: z.record(z.unknown()).optional().describe("Resolved input values"),
+    schema: z
+        .record(z.unknown())
+        .describe("Complete JSON Schema from getInputFieldsSchema (includes $schema, type, properties, required, etc.)"),
+    createdAt: z.string().describe("ISO 8601 timestamp when created"),
+});
+/**
+ * Manifest schema for version locking and saved action configurations
  */
 export const ManifestSchema = z
     .object({
@@ -12,8 +32,12 @@ export const ManifestSchema = z
             .describe("Base implementation name without version (e.g., 'SlackCLIAPI')"),
         version: z.string().describe("Version string (e.g., '1.21.1')"),
     })),
+    actions: z
+        .record(z.string(), ActionEntrySchema)
+        .optional()
+        .describe("Saved action configurations with their schemas"),
 })
-    .describe("Manifest mapping app keys to version information");
+    .describe("Manifest for app version locking and action configurations");
 export const ManifestPluginOptionsSchema = z.object({
     manifestPath: z.string().optional().describe("Path to manifest file"),
     manifest: z