runline 0.1.0

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

@@ -0,0 +1,111 @@
+const BASE_URL = "https://my.demio.com/api/v1";
+async function apiRequest(apiKey, apiSecret, method, endpoint, body, qs) {
+    const url = new URL(`${BASE_URL}${endpoint}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const opts = {
+        method,
+        headers: {
+            "Content-Type": "application/json",
+            "Api-Key": apiKey,
+            "Api-Secret": apiSecret,
+        },
+    };
+    if (body && Object.keys(body).length > 0 && method !== "GET" && method !== "DELETE") {
+        opts.body = JSON.stringify(body);
+    }
+    const res = await fetch(url.toString(), opts);
+    if (!res.ok)
+        throw new Error(`Demio API error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+function getConn(ctx) {
+    return {
+        apiKey: ctx.connection.config.apiKey,
+        apiSecret: ctx.connection.config.apiSecret,
+    };
+}
+export default function demio(rl) {
+    rl.setName("demio");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: { type: "string", required: true, description: "Demio API key", env: "DEMIO_API_KEY" },
+        apiSecret: { type: "string", required: true, description: "Demio API secret", env: "DEMIO_API_SECRET" },
+    });
+    rl.registerAction("event.get", {
+        description: "Get an event (optionally a specific session/date)",
+        inputSchema: {
+            eventId: { type: "string", required: true, description: "Event ID" },
+            dateId: { type: "string", required: false, description: "Date/session ID (for specific session)" },
+        },
+        async execute(input, ctx) {
+            const { eventId, dateId } = input;
+            const { apiKey, apiSecret } = getConn(ctx);
+            if (dateId) {
+                return apiRequest(apiKey, apiSecret, "GET", `/event/${eventId}/date/${dateId}`);
+            }
+            return apiRequest(apiKey, apiSecret, "GET", `/event/${eventId}`);
+        },
+    });
+    rl.registerAction("event.list", {
+        description: "List events",
+        inputSchema: {
+            type: { type: "string", required: false, description: "Filter: upcoming, past, all" },
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { type, limit } = (input ?? {});
+            const { apiKey, apiSecret } = getConn(ctx);
+            const qs = {};
+            if (type)
+                qs.type = type;
+            const data = (await apiRequest(apiKey, apiSecret, "GET", "/events", undefined, qs));
+            if (limit)
+                return data.slice(0, limit);
+            return data;
+        },
+    });
+    rl.registerAction("event.register", {
+        description: "Register a person for an event",
+        inputSchema: {
+            eventId: { type: "string", required: true, description: "Event ID" },
+            email: { type: "string", required: true, description: "Registrant email" },
+            firstName: { type: "string", required: true, description: "First name" },
+            lastName: { type: "string", required: false, description: "Last name" },
+            dateId: { type: "string", required: false, description: "Specific session date ID" },
+            customFields: { type: "object", required: false, description: "Custom field key-value pairs" },
+        },
+        async execute(input, ctx) {
+            const { eventId, email, firstName, lastName, dateId, customFields } = input;
+            const { apiKey, apiSecret } = getConn(ctx);
+            const body = { id: eventId, email, name: firstName };
+            if (lastName)
+                body.last_name = lastName;
+            if (dateId)
+                body.date_id = dateId;
+            if (customFields)
+                Object.assign(body, customFields);
+            return apiRequest(apiKey, apiSecret, "PUT", "/event/register", body);
+        },
+    });
+    rl.registerAction("report.getParticipants", {
+        description: "Get participants report for a session",
+        inputSchema: {
+            dateId: { type: "string", required: true, description: "Session/date ID" },
+            status: { type: "string", required: false, description: "Filter: attended, did-not-attend, banned, left-early" },
+        },
+        async execute(input, ctx) {
+            const { dateId, status } = (input ?? {});
+            const { apiKey, apiSecret } = getConn(ctx);
+            const qs = {};
+            if (status)
+                qs.status = status;
+            const data = (await apiRequest(apiKey, apiSecret, "GET", `/report/${dateId}/participants`, undefined, qs));
+            return data.participants;
+        },
+    });
+}

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

@@ -0,0 +1,40 @@
+const BASE_URL = "https://api-eu.dhl.com";
+async function apiRequest(apiKey, method, endpoint, qs) {
+    const url = new URL(`${BASE_URL}${endpoint}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const res = await fetch(url.toString(), {
+        method,
+        headers: { "DHL-API-Key": apiKey, Accept: "application/json" },
+    });
+    if (!res.ok)
+        throw new Error(`DHL API error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+export default function dhl(rl) {
+    rl.setName("dhl");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: { type: "string", required: true, description: "DHL API key", env: "DHL_API_KEY" },
+    });
+    rl.registerAction("shipment.track", {
+        description: "Get tracking details for a shipment",
+        inputSchema: {
+            trackingNumber: { type: "string", required: true, description: "DHL tracking number" },
+            recipientPostalCode: { type: "string", required: false, description: "Recipient postal code for more detailed info" },
+        },
+        async execute(input, ctx) {
+            const { trackingNumber, recipientPostalCode } = input;
+            const apiKey = ctx.connection.config.apiKey;
+            const qs = { trackingNumber };
+            if (recipientPostalCode)
+                qs.recipientPostalCode = recipientPostalCode;
+            const data = (await apiRequest(apiKey, "GET", "/track/shipments", qs));
+            return data.shipments;
+        },
+    });
+}

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

@@ -0,0 +1,275 @@
+const BASE_URL = "https://discord.com/api/v10";
+async function apiRequest(botToken, method, endpoint, body, qs) {
+    const url = new URL(`${BASE_URL}${endpoint}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const opts = {
+        method,
+        headers: {
+            Authorization: `Bot ${botToken}`,
+            "Content-Type": "application/json",
+        },
+    };
+    if (body && Object.keys(body).length > 0 && method !== "GET" && method !== "DELETE") {
+        opts.body = JSON.stringify(body);
+    }
+    const res = await fetch(url.toString(), opts);
+    if (!res.ok)
+        throw new Error(`Discord API error ${res.status}: ${await res.text()}`);
+    if (res.status === 204)
+        return { success: true };
+    return res.json();
+}
+function getConn(ctx) {
+    return {
+        botToken: ctx.connection.config.botToken,
+        guildId: ctx.connection.config.guildId,
+    };
+}
+export default function discord(rl) {
+    rl.setName("discord");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        botToken: { type: "string", required: true, description: "Discord bot token", env: "DISCORD_BOT_TOKEN" },
+        guildId: { type: "string", required: true, description: "Default guild (server) ID", env: "DISCORD_GUILD_ID" },
+    });
+    // ── Channel ─────────────────────────────────────────
+    rl.registerAction("channel.create", {
+        description: "Create a channel in the guild",
+        inputSchema: {
+            name: { type: "string", required: true, description: "Channel name" },
+            type: { type: "number", required: false, description: "Type: 0=text (default), 2=voice, 4=category" },
+            topic: { type: "string", required: false, description: "Channel topic (0-1024 chars)" },
+            parentId: { type: "string", required: false, description: "Category ID to nest under" },
+            position: { type: "number", required: false, description: "Sorting position" },
+            nsfw: { type: "boolean", required: false, description: "Mark as NSFW" },
+            bitrate: { type: "number", required: false, description: "Bitrate for voice channels (8000-96000)" },
+            userLimit: { type: "number", required: false, description: "User limit for voice channels (0=no limit)" },
+            rateLimitPerUser: { type: "number", required: false, description: "Slowmode seconds" },
+        },
+        async execute(input, ctx) {
+            const { botToken, guildId } = getConn(ctx);
+            const { name, type, topic, parentId, position, nsfw, bitrate, userLimit, rateLimitPerUser } = input;
+            const body = { name, type: type ?? 0 };
+            if (topic)
+                body.topic = topic;
+            if (parentId)
+                body.parent_id = parentId;
+            if (position !== undefined)
+                body.position = position;
+            if (nsfw !== undefined)
+                body.nsfw = nsfw;
+            if (bitrate !== undefined)
+                body.bitrate = bitrate;
+            if (userLimit !== undefined)
+                body.user_limit = userLimit;
+            if (rateLimitPerUser !== undefined)
+                body.rate_limit_per_user = rateLimitPerUser;
+            return apiRequest(botToken, "POST", `/guilds/${guildId}/channels`, body);
+        },
+    });
+    rl.registerAction("channel.get", {
+        description: "Get a channel by ID",
+        inputSchema: { channelId: { type: "string", required: true, description: "Channel ID" } },
+        async execute(input, ctx) {
+            const { botToken } = getConn(ctx);
+            return apiRequest(botToken, "GET", `/channels/${input.channelId}`);
+        },
+    });
+    rl.registerAction("channel.list", {
+        description: "List all channels in the guild",
+        inputSchema: {
+            limit: { type: "number", required: false, description: "Max results" },
+            filterType: { type: "array", required: false, description: "Filter by type numbers [0,2,4]" },
+        },
+        async execute(input, ctx) {
+            const { botToken, guildId } = getConn(ctx);
+            const { limit, filterType } = (input ?? {});
+            let channels = (await apiRequest(botToken, "GET", `/guilds/${guildId}/channels`));
+            if (filterType && Array.isArray(filterType) && filterType.length > 0) {
+                channels = channels.filter((c) => filterType.includes(c.type));
+            }
+            if (limit)
+                channels = channels.slice(0, limit);
+            return channels;
+        },
+    });
+    rl.registerAction("channel.update", {
+        description: "Update a channel",
+        inputSchema: {
+            channelId: { type: "string", required: true, description: "Channel ID" },
+            name: { type: "string", required: false, description: "New name" },
+            topic: { type: "string", required: false, description: "New topic" },
+            parentId: { type: "string", required: false, description: "New category ID" },
+            position: { type: "number", required: false, description: "New position" },
+            nsfw: { type: "boolean", required: false, description: "NSFW flag" },
+            bitrate: { type: "number", required: false, description: "Bitrate (voice)" },
+            userLimit: { type: "number", required: false, description: "User limit (voice)" },
+            rateLimitPerUser: { type: "number", required: false, description: "Slowmode seconds" },
+        },
+        async execute(input, ctx) {
+            const { botToken } = getConn(ctx);
+            const { channelId, name, topic, parentId, position, nsfw, bitrate, userLimit, rateLimitPerUser } = input;
+            const body = {};
+            if (name)
+                body.name = name;
+            if (topic !== undefined)
+                body.topic = topic;
+            if (parentId)
+                body.parent_id = parentId;
+            if (position !== undefined)
+                body.position = position;
+            if (nsfw !== undefined)
+                body.nsfw = nsfw;
+            if (bitrate !== undefined)
+                body.bitrate = bitrate;
+            if (userLimit !== undefined)
+                body.user_limit = userLimit;
+            if (rateLimitPerUser !== undefined)
+                body.rate_limit_per_user = rateLimitPerUser;
+            return apiRequest(botToken, "PATCH", `/channels/${channelId}`, body);
+        },
+    });
+    rl.registerAction("channel.delete", {
+        description: "Delete a channel",
+        inputSchema: { channelId: { type: "string", required: true, description: "Channel ID" } },
+        async execute(input, ctx) {
+            const { botToken } = getConn(ctx);
+            return apiRequest(botToken, "DELETE", `/channels/${input.channelId}`);
+        },
+    });
+    // ── Member ──────────────────────────────────────────
+    rl.registerAction("member.list", {
+        description: "List members in the guild",
+        inputSchema: {
+            limit: { type: "number", required: false, description: "Max results (default: 100, max: 1000)" },
+            after: { type: "string", required: false, description: "Fetch members after this user ID (pagination)" },
+        },
+        async execute(input, ctx) {
+            const { botToken, guildId } = getConn(ctx);
+            const { limit, after } = (input ?? {});
+            const qs = {};
+            if (limit)
+                qs.limit = limit;
+            if (after)
+                qs.after = after;
+            return apiRequest(botToken, "GET", `/guilds/${guildId}/members`, undefined, qs);
+        },
+    });
+    rl.registerAction("member.addRole", {
+        description: "Add a role to a guild member",
+        inputSchema: {
+            userId: { type: "string", required: true, description: "User ID" },
+            roleId: { type: "string", required: true, description: "Role ID" },
+        },
+        async execute(input, ctx) {
+            const { botToken, guildId } = getConn(ctx);
+            const { userId, roleId } = input;
+            await apiRequest(botToken, "PUT", `/guilds/${guildId}/members/${userId}/roles/${roleId}`);
+            return { success: true };
+        },
+    });
+    rl.registerAction("member.removeRole", {
+        description: "Remove a role from a guild member",
+        inputSchema: {
+            userId: { type: "string", required: true, description: "User ID" },
+            roleId: { type: "string", required: true, description: "Role ID" },
+        },
+        async execute(input, ctx) {
+            const { botToken, guildId } = getConn(ctx);
+            const { userId, roleId } = input;
+            await apiRequest(botToken, "DELETE", `/guilds/${guildId}/members/${userId}/roles/${roleId}`);
+            return { success: true };
+        },
+    });
+    // ── Message ─────────────────────────────────────────
+    rl.registerAction("message.send", {
+        description: "Send a message to a channel",
+        inputSchema: {
+            channelId: { type: "string", required: true, description: "Channel ID" },
+            content: { type: "string", required: true, description: "Message content (up to 2000 chars)" },
+            tts: { type: "boolean", required: false, description: "Text-to-speech" },
+            replyTo: { type: "string", required: false, description: "Message ID to reply to" },
+            embeds: { type: "array", required: false, description: "Array of embed objects" },
+        },
+        async execute(input, ctx) {
+            const { botToken } = getConn(ctx);
+            const { channelId, content, tts, replyTo, embeds } = input;
+            const body = { content };
+            if (tts)
+                body.tts = true;
+            if (replyTo)
+                body.message_reference = { message_id: replyTo };
+            if (embeds)
+                body.embeds = embeds;
+            return apiRequest(botToken, "POST", `/channels/${channelId}/messages`, body);
+        },
+    });
+    rl.registerAction("message.get", {
+        description: "Get a message by ID",
+        inputSchema: {
+            channelId: { type: "string", required: true, description: "Channel ID" },
+            messageId: { type: "string", required: true, description: "Message ID" },
+        },
+        async execute(input, ctx) {
+            const { botToken } = getConn(ctx);
+            const { channelId, messageId } = input;
+            return apiRequest(botToken, "GET", `/channels/${channelId}/messages/${messageId}`);
+        },
+    });
+    rl.registerAction("message.list", {
+        description: "List messages in a channel",
+        inputSchema: {
+            channelId: { type: "string", required: true, description: "Channel ID" },
+            limit: { type: "number", required: false, description: "Max results (default: 50, max: 100)" },
+            before: { type: "string", required: false, description: "Get messages before this ID" },
+            after: { type: "string", required: false, description: "Get messages after this ID" },
+            around: { type: "string", required: false, description: "Get messages around this ID" },
+        },
+        async execute(input, ctx) {
+            const { botToken } = getConn(ctx);
+            const { channelId, limit, before, after, around } = (input ?? {});
+            const qs = {};
+            if (limit)
+                qs.limit = limit;
+            if (before)
+                qs.before = before;
+            if (after)
+                qs.after = after;
+            if (around)
+                qs.around = around;
+            return apiRequest(botToken, "GET", `/channels/${channelId}/messages`, undefined, qs);
+        },
+    });
+    rl.registerAction("message.delete", {
+        description: "Delete a message",
+        inputSchema: {
+            channelId: { type: "string", required: true, description: "Channel ID" },
+            messageId: { type: "string", required: true, description: "Message ID" },
+        },
+        async execute(input, ctx) {
+            const { botToken } = getConn(ctx);
+            const { channelId, messageId } = input;
+            await apiRequest(botToken, "DELETE", `/channels/${channelId}/messages/${messageId}`);
+            return { success: true };
+        },
+    });
+    rl.registerAction("message.react", {
+        description: "Add a reaction to a message",
+        inputSchema: {
+            channelId: { type: "string", required: true, description: "Channel ID" },
+            messageId: { type: "string", required: true, description: "Message ID" },
+            emoji: { type: "string", required: true, description: "Emoji to react with (Unicode or name:id for custom)" },
+        },
+        async execute(input, ctx) {
+            const { botToken } = getConn(ctx);
+            const { channelId, messageId, emoji } = input;
+            await apiRequest(botToken, "PUT", `/channels/${channelId}/messages/${messageId}/reactions/${encodeURIComponent(emoji)}/@me`);
+            return { success: true };
+        },
+    });
+}