runline 0.1.0

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

@@ -0,0 +1,71 @@
+const BASE = "https://api.travis-ci.com";
+async function apiRequest(token, method, endpoint, body, qs) {
+    const url = new URL(`${BASE}${endpoint}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const init = {
+        method,
+        headers: { Authorization: `token ${token}`, "Travis-API-Version": "3", Accept: "application/json", "Content-Type": "application/json" },
+    };
+    if (body !== undefined)
+        init.body = typeof body === "string" ? body : JSON.stringify(body);
+    const res = await fetch(url.toString(), init);
+    if (!res.ok)
+        throw new Error(`TravisCI error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+export default function travisci(rl) {
+    rl.setName("travisci");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({ apiToken: { type: "string", required: true, description: "Travis CI API token", env: "TRAVISCI_API_TOKEN" } });
+    const key = (ctx) => ctx.connection.config.apiToken;
+    rl.registerAction("build.get", {
+        description: "Get a build by ID",
+        inputSchema: { buildId: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(key(ctx), "GET", `/build/${input.buildId}`); },
+    });
+    rl.registerAction("build.list", {
+        description: "List builds for the current user",
+        inputSchema: { limit: { type: "number", required: false }, sortBy: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.limit)
+                qs.limit = p.limit;
+            if (p.sortBy)
+                qs.sort_by = p.sortBy;
+            const data = (await apiRequest(key(ctx), "GET", "/builds", undefined, qs));
+            return data.builds;
+        },
+    });
+    rl.registerAction("build.cancel", {
+        description: "Cancel a build",
+        inputSchema: { buildId: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(key(ctx), "POST", `/build/${input.buildId}/cancel`); },
+    });
+    rl.registerAction("build.restart", {
+        description: "Restart a build",
+        inputSchema: { buildId: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(key(ctx), "POST", `/build/${input.buildId}/restart`); },
+    });
+    rl.registerAction("build.trigger", {
+        description: "Trigger a build for a repository",
+        inputSchema: {
+            slug: { type: "string", required: true, description: "Repository slug (owner/name)" },
+            branch: { type: "string", required: true },
+            message: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const slug = p.slug.replace(/\//g, "%2F");
+            const request = { branch: p.branch };
+            if (p.message)
+                request.message = p.message;
+            return apiRequest(key(ctx), "POST", `/repo/${slug}/requests`, { request });
+        },
+    });
+}

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

@@ -0,0 +1,341 @@
+const BASE = "https://api.trello.com/1";
+function getConn(ctx) {
+    return { apiKey: ctx.connection.config.apiKey, token: ctx.connection.config.token };
+}
+async function apiRequest(conn, method, endpoint, body, qs) {
+    const url = new URL(`${BASE}/${endpoint}`);
+    url.searchParams.set("key", conn.apiKey);
+    url.searchParams.set("token", conn.token);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const init = { method, headers: { "Content-Type": "application/json" } };
+    if (body && Object.keys(body).length > 0 && method !== "GET")
+        init.body = JSON.stringify(body);
+    const res = await fetch(url.toString(), init);
+    if (!res.ok)
+        throw new Error(`Trello error ${res.status}: ${await res.text()}`);
+    const text = await res.text();
+    return text ? JSON.parse(text) : {};
+}
+export default function trello(rl) {
+    rl.setName("trello");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: { type: "string", required: true, description: "Trello API key", env: "TRELLO_API_KEY" },
+        token: { type: "string", required: true, description: "Trello API token", env: "TRELLO_TOKEN" },
+    });
+    // ── Board ───────────────────────────────────────────
+    rl.registerAction("board.create", {
+        description: "Create a board",
+        inputSchema: { name: { type: "string", required: true }, description: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(getConn(ctx), "POST", "boards", { name: p.name, desc: p.description });
+        },
+    });
+    rl.registerAction("board.get", {
+        description: "Get a board by ID",
+        inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(getConn(ctx), "GET", `boards/${input.id}`); },
+    });
+    rl.registerAction("board.update", {
+        description: "Update a board",
+        inputSchema: { id: { type: "string", required: true }, name: { type: "string", required: false }, description: { type: "string", required: false }, closed: { type: "boolean", required: false } },
+        async execute(input, ctx) {
+            const { id, ...fields } = input;
+            const qs = {};
+            if (fields.name)
+                qs.name = fields.name;
+            if (fields.description !== undefined)
+                qs.desc = fields.description;
+            if (fields.closed !== undefined)
+                qs.closed = fields.closed;
+            return apiRequest(getConn(ctx), "PUT", `boards/${id}`, undefined, qs);
+        },
+    });
+    rl.registerAction("board.delete", {
+        description: "Delete a board",
+        inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(getConn(ctx), "DELETE", `boards/${input.id}`); },
+    });
+    // ── Board Member ────────────────────────────────────
+    rl.registerAction("boardMember.list", {
+        description: "List members of a board",
+        inputSchema: { boardId: { type: "string", required: true }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const data = (await apiRequest(getConn(ctx), "GET", `boards/${p.boardId}/members`));
+            return p.limit ? data.slice(0, p.limit) : data;
+        },
+    });
+    rl.registerAction("boardMember.add", {
+        description: "Add a member to a board",
+        inputSchema: { boardId: { type: "string", required: true }, memberId: { type: "string", required: true }, type: { type: "string", required: true, description: "admin, normal, or observer" } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(getConn(ctx), "PUT", `boards/${p.boardId}/members/${p.memberId}`, undefined, { type: p.type });
+        },
+    });
+    rl.registerAction("boardMember.remove", {
+        description: "Remove a member from a board",
+        inputSchema: { boardId: { type: "string", required: true }, memberId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(getConn(ctx), "DELETE", `boards/${p.boardId}/members/${p.memberId}`);
+        },
+    });
+    // ── Card ────────────────────────────────────────────
+    rl.registerAction("card.create", {
+        description: "Create a card",
+        inputSchema: { listId: { type: "string", required: true }, name: { type: "string", required: true }, description: { type: "string", required: false }, due: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { idList: p.listId, name: p.name };
+            if (p.description)
+                body.desc = p.description;
+            if (p.due)
+                body.due = p.due;
+            return apiRequest(getConn(ctx), "POST", "cards", body);
+        },
+    });
+    rl.registerAction("card.get", {
+        description: "Get a card by ID",
+        inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(getConn(ctx), "GET", `cards/${input.id}`); },
+    });
+    rl.registerAction("card.update", {
+        description: "Update a card",
+        inputSchema: { id: { type: "string", required: true }, name: { type: "string", required: false }, description: { type: "string", required: false }, closed: { type: "boolean", required: false }, idList: { type: "string", required: false }, due: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { id, ...fields } = input;
+            const qs = {};
+            if (fields.name)
+                qs.name = fields.name;
+            if (fields.description !== undefined)
+                qs.desc = fields.description;
+            if (fields.closed !== undefined)
+                qs.closed = fields.closed;
+            if (fields.idList)
+                qs.idList = fields.idList;
+            if (fields.due)
+                qs.due = fields.due;
+            return apiRequest(getConn(ctx), "PUT", `cards/${id}`, undefined, qs);
+        },
+    });
+    rl.registerAction("card.delete", {
+        description: "Delete a card",
+        inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(getConn(ctx), "DELETE", `cards/${input.id}`); },
+    });
+    // ── Card Comment ────────────────────────────────────
+    rl.registerAction("cardComment.create", {
+        description: "Add a comment to a card",
+        inputSchema: { cardId: { type: "string", required: true }, text: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(getConn(ctx), "POST", `cards/${p.cardId}/actions/comments`, { text: p.text });
+        },
+    });
+    rl.registerAction("cardComment.update", {
+        description: "Update a comment on a card",
+        inputSchema: { cardId: { type: "string", required: true }, commentId: { type: "string", required: true }, text: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(getConn(ctx), "PUT", `cards/${p.cardId}/actions/${p.commentId}/comments`, undefined, { text: p.text });
+        },
+    });
+    rl.registerAction("cardComment.delete", {
+        description: "Delete a comment from a card",
+        inputSchema: { cardId: { type: "string", required: true }, commentId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(getConn(ctx), "DELETE", `cards/${p.cardId}/actions/${p.commentId}/comments`);
+        },
+    });
+    // ── List ────────────────────────────────────────────
+    rl.registerAction("list.create", {
+        description: "Create a list on a board",
+        inputSchema: { boardId: { type: "string", required: true }, name: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(getConn(ctx), "POST", "lists", { idBoard: p.boardId, name: p.name });
+        },
+    });
+    rl.registerAction("list.get", {
+        description: "Get a list by ID",
+        inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(getConn(ctx), "GET", `lists/${input.id}`); },
+    });
+    rl.registerAction("list.listAll", {
+        description: "List all lists on a board",
+        inputSchema: { boardId: { type: "string", required: true }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const data = (await apiRequest(getConn(ctx), "GET", `boards/${p.boardId}/lists`));
+            return p.limit ? data.slice(0, p.limit) : data;
+        },
+    });
+    rl.registerAction("list.getCards", {
+        description: "Get cards in a list",
+        inputSchema: { listId: { type: "string", required: true }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const data = (await apiRequest(getConn(ctx), "GET", `lists/${p.listId}/cards`));
+            return p.limit ? data.slice(0, p.limit) : data;
+        },
+    });
+    rl.registerAction("list.update", {
+        description: "Update a list",
+        inputSchema: { id: { type: "string", required: true }, name: { type: "string", required: false }, closed: { type: "boolean", required: false } },
+        async execute(input, ctx) {
+            const { id, ...fields } = input;
+            const qs = {};
+            if (fields.name)
+                qs.name = fields.name;
+            if (fields.closed !== undefined)
+                qs.closed = fields.closed;
+            return apiRequest(getConn(ctx), "PUT", `lists/${id}`, undefined, qs);
+        },
+    });
+    // ── Attachment ──────────────────────────────────────
+    rl.registerAction("attachment.create", {
+        description: "Add a URL attachment to a card",
+        inputSchema: { cardId: { type: "string", required: true }, url: { type: "string", required: true }, name: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { url: p.url };
+            if (p.name)
+                body.name = p.name;
+            return apiRequest(getConn(ctx), "POST", `cards/${p.cardId}/attachments`, body);
+        },
+    });
+    rl.registerAction("attachment.get", {
+        description: "Get an attachment",
+        inputSchema: { cardId: { type: "string", required: true }, id: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(getConn(ctx), "GET", `cards/${p.cardId}/attachments/${p.id}`);
+        },
+    });
+    rl.registerAction("attachment.list", {
+        description: "List attachments on a card",
+        inputSchema: { cardId: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(getConn(ctx), "GET", `cards/${input.cardId}/attachments`); },
+    });
+    rl.registerAction("attachment.delete", {
+        description: "Delete an attachment from a card",
+        inputSchema: { cardId: { type: "string", required: true }, id: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(getConn(ctx), "DELETE", `cards/${p.cardId}/attachments/${p.id}`);
+        },
+    });
+    // ── Checklist ───────────────────────────────────────
+    rl.registerAction("checklist.create", {
+        description: "Create a checklist on a card",
+        inputSchema: { cardId: { type: "string", required: true }, name: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(getConn(ctx), "POST", `cards/${p.cardId}/checklists`, { name: p.name });
+        },
+    });
+    rl.registerAction("checklist.get", {
+        description: "Get a checklist by ID",
+        inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(getConn(ctx), "GET", `checklists/${input.id}`); },
+    });
+    rl.registerAction("checklist.list", {
+        description: "List checklists on a card",
+        inputSchema: { cardId: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(getConn(ctx), "GET", `cards/${input.cardId}/checklists`); },
+    });
+    rl.registerAction("checklist.delete", {
+        description: "Delete a checklist from a card",
+        inputSchema: { cardId: { type: "string", required: true }, id: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(getConn(ctx), "DELETE", `cards/${p.cardId}/checklists/${p.id}`);
+        },
+    });
+    rl.registerAction("checklist.createItem", {
+        description: "Create a check item in a checklist",
+        inputSchema: { checklistId: { type: "string", required: true }, name: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(getConn(ctx), "POST", `checklists/${p.checklistId}/checkItems`, { name: p.name });
+        },
+    });
+    rl.registerAction("checklist.updateItem", {
+        description: "Update a check item on a card",
+        inputSchema: { cardId: { type: "string", required: true }, checkItemId: { type: "string", required: true }, state: { type: "string", required: false, description: "complete or incomplete" }, name: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const qs = {};
+            if (p.state)
+                qs.state = p.state;
+            if (p.name)
+                qs.name = p.name;
+            return apiRequest(getConn(ctx), "PUT", `cards/${p.cardId}/checkItem/${p.checkItemId}`, undefined, qs);
+        },
+    });
+    rl.registerAction("checklist.deleteItem", {
+        description: "Delete a check item from a card",
+        inputSchema: { cardId: { type: "string", required: true }, checkItemId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(getConn(ctx), "DELETE", `cards/${p.cardId}/checkItem/${p.checkItemId}`);
+        },
+    });
+    // ── Label ───────────────────────────────────────────
+    rl.registerAction("label.create", {
+        description: "Create a label on a board",
+        inputSchema: { boardId: { type: "string", required: true }, name: { type: "string", required: true }, color: { type: "string", required: true, description: "green, yellow, orange, red, purple, blue, sky, lime, pink, black, null" } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(getConn(ctx), "POST", "labels", { idBoard: p.boardId, name: p.name, color: p.color });
+        },
+    });
+    rl.registerAction("label.get", {
+        description: "Get a label by ID",
+        inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(getConn(ctx), "GET", `labels/${input.id}`); },
+    });
+    rl.registerAction("label.list", {
+        description: "List labels on a board",
+        inputSchema: { boardId: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(getConn(ctx), "GET", `board/${input.boardId}/labels`); },
+    });
+    rl.registerAction("label.update", {
+        description: "Update a label",
+        inputSchema: { id: { type: "string", required: true }, name: { type: "string", required: false }, color: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { id, ...fields } = input;
+            return apiRequest(getConn(ctx), "PUT", `labels/${id}`, undefined, fields);
+        },
+    });
+    rl.registerAction("label.delete", {
+        description: "Delete a label",
+        inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(getConn(ctx), "DELETE", `labels/${input.id}`); },
+    });
+    rl.registerAction("label.addToCard", {
+        description: "Add a label to a card",
+        inputSchema: { cardId: { type: "string", required: true }, labelId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(getConn(ctx), "POST", `cards/${p.cardId}/idLabels`, { value: p.labelId });
+        },
+    });
+    rl.registerAction("label.removeFromCard", {
+        description: "Remove a label from a card",
+        inputSchema: { cardId: { type: "string", required: true }, labelId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(getConn(ctx), "DELETE", `cards/${p.cardId}/idLabels/${p.labelId}`);
+        },
+    });
+}

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

@@ -0,0 +1,40 @@
+export default function twake(rl) {
+    rl.setName("twake");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: { type: "string", required: true, description: "Twake workspace API key", env: "TWAKE_API_KEY" },
+    });
+    rl.registerAction("message.send", {
+        description: "Send a message to a Twake channel",
+        inputSchema: {
+            channelId: { type: "string", required: true },
+            content: { type: "string", required: true },
+            senderName: { type: "string", required: false },
+            senderIcon: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const hiddenData = { allow_delete: "everyone" };
+            if (p.senderName)
+                hiddenData.custom_title = p.senderName;
+            if (p.senderIcon)
+                hiddenData.custom_icon = p.senderIcon;
+            const body = {
+                object: {
+                    channel_id: p.channelId,
+                    content: { formatted: p.content },
+                    hidden_data: hiddenData,
+                },
+            };
+            const res = await fetch("https://plugins.twake.app/plugins/runline/actions/message/save", {
+                method: "POST",
+                headers: { Authorization: `Bearer ${ctx.connection.config.apiKey}`, "Content-Type": "application/json" },
+                body: JSON.stringify(body),
+            });
+            if (!res.ok)
+                throw new Error(`Twake error ${res.status}: ${await res.text()}`);
+            const data = (await res.json());
+            return data.object;
+        },
+    });
+}

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

@@ -0,0 +1,75 @@
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    return { accountSid: c.accountSid, authToken: c.authToken };
+}
+async function apiRequest(conn, method, endpoint, body) {
+    const url = `https://api.twilio.com/2010-04-01/Accounts/${conn.accountSid}${endpoint}`;
+    const form = new URLSearchParams();
+    for (const [k, v] of Object.entries(body)) {
+        if (v !== undefined && v !== null && v !== "")
+            form.set(k, String(v));
+    }
+    const res = await fetch(url, {
+        method,
+        headers: {
+            Authorization: `Basic ${btoa(`${conn.accountSid}:${conn.authToken}`)}`,
+            "Content-Type": "application/x-www-form-urlencoded",
+        },
+        body: form,
+    });
+    if (!res.ok)
+        throw new Error(`Twilio error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+function escapeXml(str) {
+    return str.replace(/[<>&"']/g, (ch) => ({ "<": "&lt;", ">": "&gt;", "&": "&amp;", '"': "&quot;", "'": "&apos;" })[ch] || ch);
+}
+export default function twilio(rl) {
+    rl.setName("twilio");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        accountSid: { type: "string", required: true, description: "Twilio Account SID", env: "TWILIO_ACCOUNT_SID" },
+        authToken: { type: "string", required: true, description: "Twilio Auth Token", env: "TWILIO_AUTH_TOKEN" },
+    });
+    rl.registerAction("sms.send", {
+        description: "Send an SMS, MMS, or WhatsApp message",
+        inputSchema: {
+            from: { type: "string", required: true, description: "Sender phone number" },
+            to: { type: "string", required: true, description: "Recipient phone number" },
+            body: { type: "string", required: true, description: "Message text" },
+            whatsapp: { type: "boolean", required: false, description: "Send via WhatsApp" },
+            statusCallback: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            let from = p.from;
+            let to = p.to;
+            if (p.whatsapp) {
+                from = `whatsapp:${from}`;
+                to = `whatsapp:${to}`;
+            }
+            return apiRequest(getConn(ctx), "POST", "/Messages.json", {
+                From: from, To: to, Body: p.body, StatusCallback: p.statusCallback,
+            });
+        },
+    });
+    rl.registerAction("call.make", {
+        description: "Make a phone call",
+        inputSchema: {
+            from: { type: "string", required: true },
+            to: { type: "string", required: true },
+            message: { type: "string", required: true, description: "Text to speak or TwiML" },
+            twiml: { type: "boolean", required: false, description: "If true, message is treated as raw TwiML" },
+            statusCallback: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const twiml = p.twiml
+                ? p.message
+                : `<Response><Say>${escapeXml(p.message)}</Say></Response>`;
+            return apiRequest(getConn(ctx), "POST", "/Calls.json", {
+                From: p.from, To: p.to, Twiml: twiml, StatusCallback: p.statusCallback,
+            });
+        },
+    });
+}

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

@@ -0,0 +1,90 @@
+const BASE = "https://api.twist.com/api/v3";
+async function api(token, method, endpoint, body, qs) {
+    const url = new URL(`${BASE}${endpoint}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const init = { method, headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" } };
+    if (body && Object.keys(body).length > 0)
+        init.body = JSON.stringify(body);
+    const res = await fetch(url.toString(), init);
+    if (!res.ok)
+        throw new Error(`Twist error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+export default function twist(rl) {
+    rl.setName("twist");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({ accessToken: { type: "string", required: true, description: "Twist OAuth2 access token", env: "TWIST_ACCESS_TOKEN" } });
+    const t = (ctx) => ctx.connection.config.accessToken;
+    // ── Channel ─────────────────────────────────────────
+    rl.registerAction("channel.create", { description: "Create a channel", inputSchema: { workspaceId: { type: "number", required: true }, name: { type: "string", required: true } },
+        async execute(input, ctx) { return api(t(ctx), "POST", "/channels/add", { workspace_id: input.workspaceId, name: input.name }); } });
+    rl.registerAction("channel.get", { description: "Get a channel", inputSchema: { id: { type: "number", required: true } },
+        async execute(input, ctx) { return api(t(ctx), "GET", "/channels/getone", undefined, { id: input.id }); } });
+    rl.registerAction("channel.list", { description: "List channels in a workspace", inputSchema: { workspaceId: { type: "number", required: true }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const data = (await api(t(ctx), "GET", "/channels/get", undefined, { workspace_id: p.workspaceId }));
+            return p.limit ? data.slice(0, p.limit) : data;
+        } });
+    rl.registerAction("channel.update", { description: "Update a channel", inputSchema: { id: { type: "number", required: true }, name: { type: "string", required: false }, description: { type: "string", required: false } },
+        async execute(input, ctx) { return api(t(ctx), "POST", "/channels/update", input); } });
+    rl.registerAction("channel.delete", { description: "Delete a channel", inputSchema: { id: { type: "number", required: true } },
+        async execute(input, ctx) { return api(t(ctx), "POST", "/channels/remove", undefined, { id: input.id }); } });
+    rl.registerAction("channel.archive", { description: "Archive a channel", inputSchema: { id: { type: "number", required: true } },
+        async execute(input, ctx) { return api(t(ctx), "POST", "/channels/archive", undefined, { id: input.id }); } });
+    rl.registerAction("channel.unarchive", { description: "Unarchive a channel", inputSchema: { id: { type: "number", required: true } },
+        async execute(input, ctx) { return api(t(ctx), "POST", "/channels/unarchive", undefined, { id: input.id }); } });
+    // ── Thread ──────────────────────────────────────────
+    rl.registerAction("thread.create", { description: "Create a thread", inputSchema: { channelId: { type: "number", required: true }, title: { type: "string", required: true }, content: { type: "string", required: true } },
+        async execute(input, ctx) { const p = input; return api(t(ctx), "POST", "/threads/add", { channel_id: p.channelId, title: p.title, content: p.content }); } });
+    rl.registerAction("thread.get", { description: "Get a thread", inputSchema: { id: { type: "number", required: true } },
+        async execute(input, ctx) { return api(t(ctx), "GET", "/threads/getone", undefined, { id: input.id }); } });
+    rl.registerAction("thread.list", { description: "List threads in a channel", inputSchema: { channelId: { type: "number", required: true }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const qs = { channel_id: p.channelId };
+            if (p.limit)
+                qs.limit = p.limit;
+            return api(t(ctx), "GET", "/threads/get", undefined, qs);
+        } });
+    rl.registerAction("thread.update", { description: "Update a thread", inputSchema: { id: { type: "number", required: true }, title: { type: "string", required: false }, content: { type: "string", required: false } },
+        async execute(input, ctx) { return api(t(ctx), "POST", "/threads/update", input); } });
+    rl.registerAction("thread.delete", { description: "Delete a thread", inputSchema: { id: { type: "number", required: true } },
+        async execute(input, ctx) { return api(t(ctx), "POST", "/threads/remove", undefined, { id: input.id }); } });
+    // ── Comment ─────────────────────────────────────────
+    rl.registerAction("comment.create", { description: "Add a comment to a thread", inputSchema: { threadId: { type: "number", required: true }, content: { type: "string", required: true } },
+        async execute(input, ctx) { const p = input; return api(t(ctx), "POST", "/comments/add", { thread_id: p.threadId, content: p.content }); } });
+    rl.registerAction("comment.get", { description: "Get a comment", inputSchema: { id: { type: "number", required: true } },
+        async execute(input, ctx) {
+            const data = (await api(t(ctx), "GET", "/comments/getone", undefined, { id: input.id }));
+            return data.comment ?? data;
+        } });
+    rl.registerAction("comment.list", { description: "List comments in a thread", inputSchema: { threadId: { type: "number", required: true }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const qs = { thread_id: p.threadId };
+            if (p.limit)
+                qs.limit = p.limit;
+            return api(t(ctx), "GET", "/comments/get", undefined, qs);
+        } });
+    rl.registerAction("comment.update", { description: "Update a comment", inputSchema: { id: { type: "number", required: true }, content: { type: "string", required: false } },
+        async execute(input, ctx) { return api(t(ctx), "POST", "/comments/update", input); } });
+    rl.registerAction("comment.delete", { description: "Delete a comment", inputSchema: { id: { type: "number", required: true } },
+        async execute(input, ctx) { return api(t(ctx), "POST", "/comments/remove", undefined, { id: input.id }); } });
+    // ── Message Conversation ────────────────────────────
+    rl.registerAction("messageConversation.create", { description: "Send a message in a conversation", inputSchema: { workspaceId: { type: "number", required: true }, conversationId: { type: "number", required: true }, content: { type: "string", required: true } },
+        async execute(input, ctx) { const p = input; return api(t(ctx), "POST", "/conversation_messages/add", { workspace_id: p.workspaceId, conversation_id: p.conversationId, content: p.content }); } });
+    rl.registerAction("messageConversation.get", { description: "Get a conversation message", inputSchema: { id: { type: "number", required: true } },
+        async execute(input, ctx) { return api(t(ctx), "GET", "/conversation_messages/getone", undefined, { id: input.id }); } });
+    rl.registerAction("messageConversation.list", { description: "List messages in a conversation", inputSchema: { conversationId: { type: "number", required: true } },
+        async execute(input, ctx) { return api(t(ctx), "GET", "/conversation_messages/get", undefined, { conversation_id: input.conversationId }); } });
+    rl.registerAction("messageConversation.update", { description: "Update a conversation message", inputSchema: { id: { type: "number", required: true }, content: { type: "string", required: false } },
+        async execute(input, ctx) { return api(t(ctx), "POST", "/conversation_messages/update", input); } });
+    rl.registerAction("messageConversation.delete", { description: "Delete a conversation message", inputSchema: { id: { type: "number", required: true } },
+        async execute(input, ctx) { return api(t(ctx), "POST", "/conversation_messages/remove", undefined, { id: input.id }); } });
+}