runline 0.2.0 → 0.2.2

package/dist/plugins/slack/src/index.js

@@ -6,7 +6,13 @@ async function api(token, method, endpoint, body, qs) {
                 url.searchParams.set(k, String(v));
         }
     }
-    const init = { method, headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json; charset=utf-8" } };
+    const init = {
+        method,
+        headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json; charset=utf-8",
+        },
+    };
     if (body && Object.keys(body).length > 0)
         init.body = JSON.stringify(body);
     const res = await fetch(url.toString(), init);
@@ -20,11 +26,26 @@ async function api(token, method, endpoint, body, qs) {
 export default function slack(rl) {
     rl.setName("slack");
     rl.setVersion("0.1.0");
-    rl.setConnectionSchema({ accessToken: { type: "string", required: true, description: "Slack Bot/User token", env: "SLACK_ACCESS_TOKEN" } });
+    rl.setConnectionSchema({
+        accessToken: {
+            type: "string",
+            required: true,
+            description: "Slack Bot/User token",
+            env: "SLACK_ACCESS_TOKEN",
+        },
+    });
     const t = (ctx) => ctx.connection.config.accessToken;
     // ── Message ─────────────────────────────────────────
-    rl.registerAction("message.post", { description: "Post a message to a channel or user",
-        inputSchema: { channel: { type: "string", required: true }, text: { type: "string", required: false }, blocks: { type: "object", required: false }, threadTs: { type: "string", required: false }, replyBroadcast: { type: "boolean", required: false }, unfurlLinks: { type: "boolean", required: false } },
+    rl.registerAction("message.post", {
+        description: "Post a message to a channel or user",
+        inputSchema: {
+            channel: { type: "string", required: true },
+            text: { type: "string", required: false },
+            blocks: { type: "object", required: false },
+            threadTs: { type: "string", required: false },
+            replyBroadcast: { type: "boolean", required: false },
+            unfurlLinks: { type: "boolean", required: false },
+        },
         async execute(input, ctx) {
             const p = input;
             const body = { channel: p.channel };
@@ -39,18 +60,55 @@ export default function slack(rl) {
             if (p.unfurlLinks !== undefined)
                 body.unfurl_links = p.unfurlLinks;
             return api(t(ctx), "POST", "/chat.postMessage", body);
-        } });
-    rl.registerAction("message.update", { description: "Update a message",
-        inputSchema: { channel: { type: "string", required: true }, ts: { type: "string", required: true }, text: { type: "string", required: false }, blocks: { type: "object", required: false } },
-        async execute(input, ctx) { return api(t(ctx), "POST", "/chat.update", input); } });
-    rl.registerAction("message.delete", { description: "Delete a message",
-        inputSchema: { channel: { type: "string", required: true }, ts: { type: "string", required: true } },
-        async execute(input, ctx) { return api(t(ctx), "POST", "/chat.delete", input); } });
-    rl.registerAction("message.getPermalink", { description: "Get a message permalink",
-        inputSchema: { channel: { type: "string", required: true }, messageTs: { type: "string", required: true } },
-        async execute(input, ctx) { const p = input; return api(t(ctx), "GET", "/chat.getPermalink", undefined, { channel: p.channel, message_ts: p.messageTs }); } });
-    rl.registerAction("message.search", { description: "Search messages",
-        inputSchema: { query: { type: "string", required: true }, sort: { type: "string", required: false, description: "score or timestamp" }, limit: { type: "number", required: false } },
+        },
+    });
+    rl.registerAction("message.update", {
+        description: "Update a message",
+        inputSchema: {
+            channel: { type: "string", required: true },
+            ts: { type: "string", required: true },
+            text: { type: "string", required: false },
+            blocks: { type: "object", required: false },
+        },
+        async execute(input, ctx) {
+            return api(t(ctx), "POST", "/chat.update", input);
+        },
+    });
+    rl.registerAction("message.delete", {
+        description: "Delete a message",
+        inputSchema: {
+            channel: { type: "string", required: true },
+            ts: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            return api(t(ctx), "POST", "/chat.delete", input);
+        },
+    });
+    rl.registerAction("message.getPermalink", {
+        description: "Get a message permalink",
+        inputSchema: {
+            channel: { type: "string", required: true },
+            messageTs: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            return api(t(ctx), "GET", "/chat.getPermalink", undefined, {
+                channel: p.channel,
+                message_ts: p.messageTs,
+            });
+        },
+    });
+    rl.registerAction("message.search", {
+        description: "Search messages",
+        inputSchema: {
+            query: { type: "string", required: true },
+            sort: {
+                type: "string",
+                required: false,
+                description: "score or timestamp",
+            },
+            limit: { type: "number", required: false },
+        },
         async execute(input, ctx) {
             const p = input;
             const qs = { query: p.query };
@@ -60,32 +118,64 @@ export default function slack(rl) {
                 qs.count = p.limit;
             const data = (await api(t(ctx), "POST", "/search.messages", undefined, qs));
             return data.messages?.matches;
-        } });
+        },
+    });
     // ── Channel ─────────────────────────────────────────
-    rl.registerAction("channel.create", { description: "Create a channel",
-        inputSchema: { name: { type: "string", required: true }, isPrivate: { type: "boolean", required: false } },
+    rl.registerAction("channel.create", {
+        description: "Create a channel",
+        inputSchema: {
+            name: { type: "string", required: true },
+            isPrivate: { type: "boolean", required: false },
+        },
         async execute(input, ctx) {
             const p = input;
-            const data = (await api(t(ctx), "POST", "/conversations.create", { name: p.name, is_private: p.isPrivate ?? false }));
+            const data = (await api(t(ctx), "POST", "/conversations.create", {
+                name: p.name,
+                is_private: p.isPrivate ?? false,
+            }));
             return data.channel;
-        } });
-    rl.registerAction("channel.get", { description: "Get channel info",
+        },
+    });
+    rl.registerAction("channel.get", {
+        description: "Get channel info",
         inputSchema: { channel: { type: "string", required: true } },
-        async execute(input, ctx) { const data = (await api(t(ctx), "POST", "/conversations.info", undefined, { channel: input.channel })); return data.channel; } });
-    rl.registerAction("channel.list", { description: "List channels",
-        inputSchema: { limit: { type: "number", required: false }, types: { type: "string", required: false, description: "Comma-separated: public_channel,private_channel" }, excludeArchived: { type: "boolean", required: false } },
+        async execute(input, ctx) {
+            const data = (await api(t(ctx), "POST", "/conversations.info", undefined, { channel: input.channel }));
+            return data.channel;
+        },
+    });
+    rl.registerAction("channel.list", {
+        description: "List channels",
+        inputSchema: {
+            limit: { type: "number", required: false },
+            types: {
+                type: "string",
+                required: false,
+                description: "Comma-separated: public_channel,private_channel",
+            },
+            excludeArchived: { type: "boolean", required: false },
+        },
         async execute(input, ctx) {
             const p = (input ?? {});
-            const qs = { types: p.types ?? "public_channel,private_channel" };
+            const qs = {
+                types: p.types ?? "public_channel,private_channel",
+            };
             if (p.limit)
                 qs.limit = p.limit;
             if (p.excludeArchived)
                 qs.exclude_archived = true;
             const data = (await api(t(ctx), "GET", "/conversations.list", undefined, qs));
             return data.channels;
-        } });
-    rl.registerAction("channel.history", { description: "Get channel message history",
-        inputSchema: { channel: { type: "string", required: true }, limit: { type: "number", required: false }, oldest: { type: "string", required: false, description: "ISO datetime" }, latest: { type: "string", required: false } },
+        },
+    });
+    rl.registerAction("channel.history", {
+        description: "Get channel message history",
+        inputSchema: {
+            channel: { type: "string", required: true },
+            limit: { type: "number", required: false },
+            oldest: { type: "string", required: false, description: "ISO datetime" },
+            latest: { type: "string", required: false },
+        },
         async execute(input, ctx) {
             const p = input;
             const qs = { channel: p.channel };
@@ -97,9 +187,15 @@ export default function slack(rl) {
                 qs.latest = new Date(p.latest).getTime() / 1000;
             const data = (await api(t(ctx), "GET", "/conversations.history", undefined, qs));
             return data.messages;
-        } });
-    rl.registerAction("channel.replies", { description: "Get thread replies",
-        inputSchema: { channel: { type: "string", required: true }, ts: { type: "string", required: true }, limit: { type: "number", required: false } },
+        },
+    });
+    rl.registerAction("channel.replies", {
+        description: "Get thread replies",
+        inputSchema: {
+            channel: { type: "string", required: true },
+            ts: { type: "string", required: true },
+            limit: { type: "number", required: false },
+        },
         async execute(input, ctx) {
             const p = input;
             const qs = { channel: p.channel, ts: p.ts };
@@ -107,59 +203,172 @@ export default function slack(rl) {
                 qs.limit = p.limit;
             const data = (await api(t(ctx), "GET", "/conversations.replies", undefined, qs));
             return data.messages;
-        } });
-    rl.registerAction("channel.invite", { description: "Invite users to a channel",
-        inputSchema: { channel: { type: "string", required: true }, users: { type: "string", required: true, description: "Comma-separated user IDs" } },
-        async execute(input, ctx) { const p = input; const data = (await api(t(ctx), "POST", "/conversations.invite", { channel: p.channel, users: p.users })); return data.channel; } });
-    rl.registerAction("channel.kick", { description: "Remove a user from a channel",
-        inputSchema: { channel: { type: "string", required: true }, user: { type: "string", required: true } },
-        async execute(input, ctx) { return api(t(ctx), "POST", "/conversations.kick", input); } });
-    rl.registerAction("channel.join", { description: "Join a channel",
+        },
+    });
+    rl.registerAction("channel.invite", {
+        description: "Invite users to a channel",
+        inputSchema: {
+            channel: { type: "string", required: true },
+            users: {
+                type: "string",
+                required: true,
+                description: "Comma-separated user IDs",
+            },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const data = (await api(t(ctx), "POST", "/conversations.invite", {
+                channel: p.channel,
+                users: p.users,
+            }));
+            return data.channel;
+        },
+    });
+    rl.registerAction("channel.kick", {
+        description: "Remove a user from a channel",
+        inputSchema: {
+            channel: { type: "string", required: true },
+            user: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            return api(t(ctx), "POST", "/conversations.kick", input);
+        },
+    });
+    rl.registerAction("channel.join", {
+        description: "Join a channel",
         inputSchema: { channel: { type: "string", required: true } },
-        async execute(input, ctx) { const data = (await api(t(ctx), "POST", "/conversations.join", { channel: input.channel })); return data.channel; } });
-    rl.registerAction("channel.leave", { description: "Leave a channel",
+        async execute(input, ctx) {
+            const data = (await api(t(ctx), "POST", "/conversations.join", {
+                channel: input.channel,
+            }));
+            return data.channel;
+        },
+    });
+    rl.registerAction("channel.leave", {
+        description: "Leave a channel",
         inputSchema: { channel: { type: "string", required: true } },
-        async execute(input, ctx) { return api(t(ctx), "POST", "/conversations.leave", { channel: input.channel }); } });
-    rl.registerAction("channel.archive", { description: "Archive a channel",
+        async execute(input, ctx) {
+            return api(t(ctx), "POST", "/conversations.leave", {
+                channel: input.channel,
+            });
+        },
+    });
+    rl.registerAction("channel.archive", {
+        description: "Archive a channel",
         inputSchema: { channel: { type: "string", required: true } },
-        async execute(input, ctx) { return api(t(ctx), "POST", "/conversations.archive", { channel: input.channel }); } });
-    rl.registerAction("channel.unarchive", { description: "Unarchive a channel",
+        async execute(input, ctx) {
+            return api(t(ctx), "POST", "/conversations.archive", {
+                channel: input.channel,
+            });
+        },
+    });
+    rl.registerAction("channel.unarchive", {
+        description: "Unarchive a channel",
         inputSchema: { channel: { type: "string", required: true } },
-        async execute(input, ctx) { return api(t(ctx), "POST", "/conversations.unarchive", { channel: input.channel }); } });
-    rl.registerAction("channel.rename", { description: "Rename a channel",
-        inputSchema: { channel: { type: "string", required: true }, name: { type: "string", required: true } },
-        async execute(input, ctx) { const data = (await api(t(ctx), "POST", "/conversations.rename", input)); return data.channel; } });
-    rl.registerAction("channel.setTopic", { description: "Set channel topic",
-        inputSchema: { channel: { type: "string", required: true }, topic: { type: "string", required: true } },
-        async execute(input, ctx) { const data = (await api(t(ctx), "POST", "/conversations.setTopic", input)); return data.channel; } });
-    rl.registerAction("channel.setPurpose", { description: "Set channel purpose",
-        inputSchema: { channel: { type: "string", required: true }, purpose: { type: "string", required: true } },
-        async execute(input, ctx) { const data = (await api(t(ctx), "POST", "/conversations.setPurpose", input)); return data.channel; } });
-    rl.registerAction("channel.members", { description: "List channel members",
-        inputSchema: { channel: { type: "string", required: true }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            return api(t(ctx), "POST", "/conversations.unarchive", {
+                channel: input.channel,
+            });
+        },
+    });
+    rl.registerAction("channel.rename", {
+        description: "Rename a channel",
+        inputSchema: {
+            channel: { type: "string", required: true },
+            name: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            const data = (await api(t(ctx), "POST", "/conversations.rename", input));
+            return data.channel;
+        },
+    });
+    rl.registerAction("channel.setTopic", {
+        description: "Set channel topic",
+        inputSchema: {
+            channel: { type: "string", required: true },
+            topic: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            const data = (await api(t(ctx), "POST", "/conversations.setTopic", input));
+            return data.channel;
+        },
+    });
+    rl.registerAction("channel.setPurpose", {
+        description: "Set channel purpose",
+        inputSchema: {
+            channel: { type: "string", required: true },
+            purpose: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            const data = (await api(t(ctx), "POST", "/conversations.setPurpose", input));
+            return data.channel;
+        },
+    });
+    rl.registerAction("channel.members", {
+        description: "List channel members",
+        inputSchema: {
+            channel: { type: "string", required: true },
+            limit: { type: "number", required: false },
+        },
         async execute(input, ctx) {
             const p = input;
             const qs = { channel: p.channel };
             if (p.limit)
                 qs.limit = p.limit;
             const data = (await api(t(ctx), "GET", "/conversations.members", undefined, qs));
-            return data.members.map(m => ({ member: m }));
-        } });
+            return data.members.map((m) => ({ member: m }));
+        },
+    });
     // ── Reaction ────────────────────────────────────────
-    rl.registerAction("reaction.add", { description: "Add a reaction to a message",
-        inputSchema: { channel: { type: "string", required: true }, timestamp: { type: "string", required: true }, name: { type: "string", required: true, description: "Emoji name without colons" } },
-        async execute(input, ctx) { return api(t(ctx), "POST", "/reactions.add", input); } });
-    rl.registerAction("reaction.remove", { description: "Remove a reaction",
-        inputSchema: { channel: { type: "string", required: true }, timestamp: { type: "string", required: true }, name: { type: "string", required: true } },
-        async execute(input, ctx) { return api(t(ctx), "POST", "/reactions.remove", input); } });
-    rl.registerAction("reaction.get", { description: "Get reactions for a message",
-        inputSchema: { channel: { type: "string", required: true }, timestamp: { type: "string", required: true } },
-        async execute(input, ctx) { return api(t(ctx), "GET", "/reactions.get", undefined, input); } });
+    rl.registerAction("reaction.add", {
+        description: "Add a reaction to a message",
+        inputSchema: {
+            channel: { type: "string", required: true },
+            timestamp: { type: "string", required: true },
+            name: {
+                type: "string",
+                required: true,
+                description: "Emoji name without colons",
+            },
+        },
+        async execute(input, ctx) {
+            return api(t(ctx), "POST", "/reactions.add", input);
+        },
+    });
+    rl.registerAction("reaction.remove", {
+        description: "Remove a reaction",
+        inputSchema: {
+            channel: { type: "string", required: true },
+            timestamp: { type: "string", required: true },
+            name: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            return api(t(ctx), "POST", "/reactions.remove", input);
+        },
+    });
+    rl.registerAction("reaction.get", {
+        description: "Get reactions for a message",
+        inputSchema: {
+            channel: { type: "string", required: true },
+            timestamp: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            return api(t(ctx), "GET", "/reactions.get", undefined, input);
+        },
+    });
     // ── User ────────────────────────────────────────────
-    rl.registerAction("user.info", { description: "Get user info",
+    rl.registerAction("user.info", {
+        description: "Get user info",
         inputSchema: { user: { type: "string", required: true } },
-        async execute(input, ctx) { const data = (await api(t(ctx), "GET", "/users.info", undefined, { user: input.user })); return data.user; } });
-    rl.registerAction("user.list", { description: "List all users",
+        async execute(input, ctx) {
+            const data = (await api(t(ctx), "GET", "/users.info", undefined, {
+                user: input.user,
+            }));
+            return data.user;
+        },
+    });
+    rl.registerAction("user.list", {
+        description: "List all users",
         inputSchema: { limit: { type: "number", required: false } },
         async execute(input, ctx) {
             const qs = {};
@@ -167,21 +376,58 @@ export default function slack(rl) {
                 qs.limit = input.limit;
             const data = (await api(t(ctx), "GET", "/users.list", undefined, qs));
             return data.members;
-        } });
-    rl.registerAction("user.getPresence", { description: "Get a user's presence",
+        },
+    });
+    rl.registerAction("user.getPresence", {
+        description: "Get a user's presence",
         inputSchema: { user: { type: "string", required: true } },
-        async execute(input, ctx) { return api(t(ctx), "GET", "/users.getPresence", undefined, { user: input.user }); } });
-    rl.registerAction("user.getProfile", { description: "Get a user's profile",
+        async execute(input, ctx) {
+            return api(t(ctx), "GET", "/users.getPresence", undefined, {
+                user: input.user,
+            });
+        },
+    });
+    rl.registerAction("user.getProfile", {
+        description: "Get a user's profile",
         inputSchema: { user: { type: "string", required: true } },
-        async execute(input, ctx) { const data = (await api(t(ctx), "GET", "/users.profile.get", undefined, { user: input.user })); return data.profile; } });
-    rl.registerAction("user.updateProfile", { description: "Update the authenticated user's profile",
-        inputSchema: { profile: { type: "object", required: true, description: "Profile fields to set" } },
-        async execute(input, ctx) { const data = (await api(t(ctx), "POST", "/users.profile.set", { profile: input.profile })); return data.profile; } });
+        async execute(input, ctx) {
+            const data = (await api(t(ctx), "GET", "/users.profile.get", undefined, {
+                user: input.user,
+            }));
+            return data.profile;
+        },
+    });
+    rl.registerAction("user.updateProfile", {
+        description: "Update the authenticated user's profile",
+        inputSchema: {
+            profile: {
+                type: "object",
+                required: true,
+                description: "Profile fields to set",
+            },
+        },
+        async execute(input, ctx) {
+            const data = (await api(t(ctx), "POST", "/users.profile.set", {
+                profile: input.profile,
+            }));
+            return data.profile;
+        },
+    });
     // ── User Group ──────────────────────────────────────
-    rl.registerAction("userGroup.create", { description: "Create a user group",
-        inputSchema: { name: { type: "string", required: true }, handle: { type: "string", required: false }, description: { type: "string", required: false } },
-        async execute(input, ctx) { const data = (await api(t(ctx), "POST", "/usergroups.create", input)); return data.usergroup; } });
-    rl.registerAction("userGroup.list", { description: "List user groups",
+    rl.registerAction("userGroup.create", {
+        description: "Create a user group",
+        inputSchema: {
+            name: { type: "string", required: true },
+            handle: { type: "string", required: false },
+            description: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const data = (await api(t(ctx), "POST", "/usergroups.create", input));
+            return data.usergroup;
+        },
+    });
+    rl.registerAction("userGroup.list", {
+        description: "List user groups",
         inputSchema: { includeUsers: { type: "boolean", required: false } },
         async execute(input, ctx) {
             const qs = {};
@@ -189,22 +435,59 @@ export default function slack(rl) {
                 qs.include_users = true;
             const data = (await api(t(ctx), "GET", "/usergroups.list", undefined, qs));
             return data.usergroups;
-        } });
-    rl.registerAction("userGroup.update", { description: "Update a user group",
-        inputSchema: { usergroup: { type: "string", required: true }, name: { type: "string", required: false }, handle: { type: "string", required: false }, description: { type: "string", required: false } },
-        async execute(input, ctx) { const data = (await api(t(ctx), "POST", "/usergroups.update", input)); return data.usergroup; } });
-    rl.registerAction("userGroup.enable", { description: "Enable a user group",
+        },
+    });
+    rl.registerAction("userGroup.update", {
+        description: "Update a user group",
+        inputSchema: {
+            usergroup: { type: "string", required: true },
+            name: { type: "string", required: false },
+            handle: { type: "string", required: false },
+            description: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const data = (await api(t(ctx), "POST", "/usergroups.update", input));
+            return data.usergroup;
+        },
+    });
+    rl.registerAction("userGroup.enable", {
+        description: "Enable a user group",
         inputSchema: { usergroup: { type: "string", required: true } },
-        async execute(input, ctx) { const data = (await api(t(ctx), "POST", "/usergroups.enable", { usergroup: input.usergroup })); return data.usergroup; } });
-    rl.registerAction("userGroup.disable", { description: "Disable a user group",
+        async execute(input, ctx) {
+            const data = (await api(t(ctx), "POST", "/usergroups.enable", {
+                usergroup: input.usergroup,
+            }));
+            return data.usergroup;
+        },
+    });
+    rl.registerAction("userGroup.disable", {
+        description: "Disable a user group",
         inputSchema: { usergroup: { type: "string", required: true } },
-        async execute(input, ctx) { const data = (await api(t(ctx), "POST", "/usergroups.disable", { usergroup: input.usergroup })); return data.usergroup; } });
+        async execute(input, ctx) {
+            const data = (await api(t(ctx), "POST", "/usergroups.disable", {
+                usergroup: input.usergroup,
+            }));
+            return data.usergroup;
+        },
+    });
     // ── File ────────────────────────────────────────────
-    rl.registerAction("file.get", { description: "Get file info",
+    rl.registerAction("file.get", {
+        description: "Get file info",
         inputSchema: { file: { type: "string", required: true } },
-        async execute(input, ctx) { const data = (await api(t(ctx), "GET", "/files.info", undefined, { file: input.file })); return data.file; } });
-    rl.registerAction("file.list", { description: "List files",
-        inputSchema: { channel: { type: "string", required: false }, limit: { type: "number", required: false }, types: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const data = (await api(t(ctx), "GET", "/files.info", undefined, {
+                file: input.file,
+            }));
+            return data.file;
+        },
+    });
+    rl.registerAction("file.list", {
+        description: "List files",
+        inputSchema: {
+            channel: { type: "string", required: false },
+            limit: { type: "number", required: false },
+            types: { type: "string", required: false },
+        },
         async execute(input, ctx) {
             const p = (input ?? {});
             const qs = {};
@@ -216,15 +499,33 @@ export default function slack(rl) {
                 qs.types = p.types;
             const data = (await api(t(ctx), "GET", "/files.list", undefined, qs));
             return data.files;
-        } });
+        },
+    });
     // ── Star ────────────────────────────────────────────
-    rl.registerAction("star.add", { description: "Star an item",
-        inputSchema: { channel: { type: "string", required: false }, timestamp: { type: "string", required: false }, file: { type: "string", required: false } },
-        async execute(input, ctx) { return api(t(ctx), "POST", "/stars.add", input); } });
-    rl.registerAction("star.remove", { description: "Unstar an item",
-        inputSchema: { channel: { type: "string", required: false }, timestamp: { type: "string", required: false }, file: { type: "string", required: false } },
-        async execute(input, ctx) { return api(t(ctx), "POST", "/stars.remove", input); } });
-    rl.registerAction("star.list", { description: "List starred items",
+    rl.registerAction("star.add", {
+        description: "Star an item",
+        inputSchema: {
+            channel: { type: "string", required: false },
+            timestamp: { type: "string", required: false },
+            file: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            return api(t(ctx), "POST", "/stars.add", input);
+        },
+    });
+    rl.registerAction("star.remove", {
+        description: "Unstar an item",
+        inputSchema: {
+            channel: { type: "string", required: false },
+            timestamp: { type: "string", required: false },
+            file: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            return api(t(ctx), "POST", "/stars.remove", input);
+        },
+    });
+    rl.registerAction("star.list", {
+        description: "List starred items",
         inputSchema: { limit: { type: "number", required: false } },
         async execute(input, ctx) {
             const qs = {};
@@ -232,5 +533,6 @@ export default function slack(rl) {
                 qs.limit = input.limit;
             const data = (await api(t(ctx), "GET", "/stars.list", undefined, qs));
             return data.items;
-        } });
+        },
+    });
 }