runline 0.1.0

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

@@ -0,0 +1,255 @@
+function getConn(ctx) {
+    const subdomain = ctx.connection.config.subdomain;
+    const apiKey = ctx.connection.config.apiKey;
+    return { base: `https://${subdomain}.syncromsp.com/api/v1`, apiKey };
+}
+async function api(base, apiKey, method, endpoint, body, qs) {
+    const url = new URL(`${base}/${endpoint}`);
+    url.searchParams.set("api_key", apiKey);
+    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)
+        init.body = JSON.stringify(body);
+    const res = await fetch(url.toString(), init);
+    if (!res.ok)
+        throw new Error(`SyncroMSP error ${res.status}: ${await res.text()}`);
+    const text = await res.text();
+    return text ? JSON.parse(text) : { success: true };
+}
+async function paginate(base, apiKey, endpoint, key, qs = {}) {
+    const results = [];
+    let page = 1;
+    let batch;
+    do {
+        qs.page = page;
+        const res = await api(base, apiKey, "GET", endpoint, undefined, qs);
+        batch = (res[key] ?? []);
+        results.push(...batch);
+        page++;
+    } while (batch.length > 0);
+    return results;
+}
+export default function syncromsp(rl) {
+    rl.setName("syncromsp");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        subdomain: { type: "string", required: true, description: "SyncroMSP subdomain", env: "SYNCROMSP_SUBDOMAIN" },
+        apiKey: { type: "string", required: true, description: "API key", env: "SYNCROMSP_API_KEY" },
+    });
+    // ── Customer ────────────────────────────────────────
+    rl.registerAction("customer.create", { description: "Create a customer",
+        inputSchema: { email: { type: "string", required: true }, businessName: { type: "string", required: false }, firstName: { type: "string", required: false }, lastname: { type: "string", required: false }, phone: { type: "string", required: false }, notes: { type: "string", required: false }, address: { type: "string", required: false }, city: { type: "string", required: false }, state: { type: "string", required: false }, zip: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { base, apiKey } = getConn(ctx);
+            const p = input;
+            const body = { email: p.email };
+            if (p.businessName)
+                body.business_name = p.businessName;
+            if (p.firstName)
+                body.firstname = p.firstName;
+            if (p.lastname)
+                body.lastname = p.lastname;
+            if (p.phone)
+                body.phone = p.phone;
+            if (p.notes)
+                body.notes = p.notes;
+            if (p.address)
+                body.address = p.address;
+            if (p.city)
+                body.city = p.city;
+            if (p.state)
+                body.state = p.state;
+            if (p.zip)
+                body.zip = p.zip;
+            const res = await api(base, apiKey, "POST", "customers", body);
+            return res.customer ?? res;
+        } });
+    rl.registerAction("customer.get", { description: "Get a customer", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { const { base, apiKey } = getConn(ctx); const res = await api(base, apiKey, "GET", `customers/${input.id}`); return res.customer ?? res; } });
+    rl.registerAction("customer.list", { description: "List customers",
+        inputSchema: { limit: { type: "number", required: false }, businessName: { type: "string", required: false }, includeDisabled: { type: "boolean", required: false } },
+        async execute(input, ctx) {
+            const { base, apiKey } = getConn(ctx);
+            const p = (input ?? {});
+            const qs = {};
+            if (p.businessName)
+                qs.business_name = p.businessName;
+            if (p.includeDisabled)
+                qs.include_disabled = true;
+            if (p.limit) {
+                qs.per_page = p.limit;
+                const res = await api(base, apiKey, "GET", "customers", undefined, qs);
+                return res.customers ?? res;
+            }
+            return paginate(base, apiKey, "customers", "customers", qs);
+        } });
+    rl.registerAction("customer.update", { description: "Update a customer",
+        inputSchema: { id: { type: "string", required: true }, email: { type: "string", required: false }, businessName: { type: "string", required: false }, firstName: { type: "string", required: false }, lastname: { type: "string", required: false }, phone: { type: "string", required: false }, notes: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { base, apiKey } = getConn(ctx);
+            const { id, ...fields } = input;
+            const body = {};
+            if (fields.email)
+                body.email = fields.email;
+            if (fields.businessName)
+                body.business_name = fields.businessName;
+            if (fields.firstName)
+                body.firstname = fields.firstName;
+            if (fields.lastname)
+                body.lastname = fields.lastname;
+            if (fields.phone)
+                body.phone = fields.phone;
+            if (fields.notes)
+                body.notes = fields.notes;
+            const res = await api(base, apiKey, "PUT", `customers/${id}`, body);
+            return res.customer ?? res;
+        } });
+    rl.registerAction("customer.delete", { description: "Delete a customer", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { const { base, apiKey } = getConn(ctx); await api(base, apiKey, "DELETE", `customers/${input.id}`); return { success: true }; } });
+    // ── Contact ─────────────────────────────────────────
+    rl.registerAction("contact.create", { description: "Create a contact",
+        inputSchema: { customerId: { type: "string", required: true }, email: { type: "string", required: true }, name: { type: "string", required: false }, phone: { type: "string", required: false }, notes: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { base, apiKey } = getConn(ctx);
+            const p = input;
+            const body = { customer_id: p.customerId, email: p.email };
+            if (p.name)
+                body.name = p.name;
+            if (p.phone)
+                body.phone = p.phone;
+            if (p.notes)
+                body.notes = p.notes;
+            return api(base, apiKey, "POST", "contacts", body);
+        } });
+    rl.registerAction("contact.get", { description: "Get a contact", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { const { base, apiKey } = getConn(ctx); return api(base, apiKey, "GET", `contacts/${input.id}`); } });
+    rl.registerAction("contact.list", { description: "List contacts",
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const { base, apiKey } = getConn(ctx);
+            const p = (input ?? {});
+            if (p.limit) {
+                const res = await api(base, apiKey, "GET", "contacts");
+                return (res.contacts ?? []).slice(0, p.limit);
+            }
+            return paginate(base, apiKey, "contacts", "contacts");
+        } });
+    rl.registerAction("contact.update", { description: "Update a contact",
+        inputSchema: { id: { type: "string", required: true }, customerId: { type: "string", required: false }, email: { type: "string", required: false }, name: { type: "string", required: false }, phone: { type: "string", required: false }, notes: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { base, apiKey } = getConn(ctx);
+            const { id, ...fields } = input;
+            const body = {};
+            if (fields.customerId)
+                body.customer_id = fields.customerId;
+            if (fields.email)
+                body.email = fields.email;
+            if (fields.name)
+                body.name = fields.name;
+            if (fields.phone)
+                body.phone = fields.phone;
+            if (fields.notes)
+                body.notes = fields.notes;
+            return api(base, apiKey, "PUT", `contacts/${id}`, body);
+        } });
+    rl.registerAction("contact.delete", { description: "Delete a contact", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { const { base, apiKey } = getConn(ctx); await api(base, apiKey, "DELETE", `contacts/${input.id}`); return { success: true }; } });
+    // ── Ticket ──────────────────────────────────────────
+    rl.registerAction("ticket.create", { description: "Create a ticket",
+        inputSchema: { customerId: { type: "string", required: true }, subject: { type: "string", required: true }, issueType: { type: "string", required: false }, status: { type: "string", required: false }, assetId: { type: "string", required: false }, contactId: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { base, apiKey } = getConn(ctx);
+            const p = input;
+            const body = { customer_id: p.customerId, subject: p.subject };
+            if (p.issueType)
+                body.problem_type = p.issueType;
+            if (p.status)
+                body.status = p.status;
+            if (p.assetId)
+                body.asset_id = p.assetId;
+            if (p.contactId)
+                body.contact_id = p.contactId;
+            const res = await api(base, apiKey, "POST", "tickets", body);
+            return res.ticket ?? res;
+        } });
+    rl.registerAction("ticket.get", { description: "Get a ticket", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { const { base, apiKey } = getConn(ctx); const res = await api(base, apiKey, "GET", `tickets/${input.id}`); return res.ticket ?? res; } });
+    rl.registerAction("ticket.list", { description: "List tickets",
+        inputSchema: { limit: { type: "number", required: false }, status: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { base, apiKey } = getConn(ctx);
+            const p = (input ?? {});
+            const qs = {};
+            if (p.status)
+                qs.status = p.status;
+            if (p.limit) {
+                qs.per_page = p.limit;
+                const res = await api(base, apiKey, "GET", "tickets", undefined, qs);
+                return res.tickets ?? res;
+            }
+            return paginate(base, apiKey, "tickets", "tickets", qs);
+        } });
+    rl.registerAction("ticket.update", { description: "Update a ticket",
+        inputSchema: { id: { type: "string", required: true }, subject: { type: "string", required: false }, status: { type: "string", required: false }, issueType: { type: "string", required: false }, customerId: { type: "string", required: false }, assetId: { type: "string", required: false }, dueDate: { type: "string", required: false }, contactId: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { base, apiKey } = getConn(ctx);
+            const { id, ...fields } = input;
+            const body = {};
+            if (fields.subject)
+                body.subject = fields.subject;
+            if (fields.status)
+                body.status = fields.status;
+            if (fields.issueType)
+                body.problem_type = fields.issueType;
+            if (fields.customerId)
+                body.customer_id = fields.customerId;
+            if (fields.assetId)
+                body.asset_id = fields.assetId;
+            if (fields.dueDate)
+                body.due_date = fields.dueDate;
+            if (fields.contactId)
+                body.contact_id = fields.contactId;
+            const res = await api(base, apiKey, "PUT", `tickets/${id}`, body);
+            return res.ticket ?? res;
+        } });
+    rl.registerAction("ticket.delete", { description: "Delete a ticket", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { const { base, apiKey } = getConn(ctx); await api(base, apiKey, "DELETE", `tickets/${input.id}`); return { success: true }; } });
+    // ── RMM Alerts ──────────────────────────────────────
+    rl.registerAction("rmmAlert.create", { description: "Create an RMM alert",
+        inputSchema: { customerId: { type: "string", required: true }, assetId: { type: "string", required: true }, description: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { base, apiKey } = getConn(ctx);
+            const p = input;
+            const res = await api(base, apiKey, "POST", "rmm_alerts", { customer_id: p.customerId, asset_id: p.assetId, description: p.description });
+            return res.alert ?? res;
+        } });
+    rl.registerAction("rmmAlert.get", { description: "Get an RMM alert", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { const { base, apiKey } = getConn(ctx); const res = await api(base, apiKey, "GET", `rmm_alerts/${input.id}`); return res.rmm_alert ?? res; } });
+    rl.registerAction("rmmAlert.list", { description: "List RMM alerts",
+        inputSchema: { limit: { type: "number", required: false }, status: { type: "string", required: false, description: "all, active, or resolved" } },
+        async execute(input, ctx) {
+            const { base, apiKey } = getConn(ctx);
+            const p = (input ?? {});
+            const qs = { status: p.status ?? "all" };
+            if (p.limit) {
+                qs.per_page = p.limit;
+                const res = await api(base, apiKey, "GET", "rmm_alerts", undefined, qs);
+                return res.rmm_alerts ?? res;
+            }
+            return paginate(base, apiKey, "rmm_alerts", "rmm_alerts", qs);
+        } });
+    rl.registerAction("rmmAlert.delete", { description: "Delete an RMM alert", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { const { base, apiKey } = getConn(ctx); await api(base, apiKey, "DELETE", `rmm_alerts/${input.id}`); return { success: true }; } });
+    rl.registerAction("rmmAlert.mute", { description: "Mute an RMM alert",
+        inputSchema: { id: { type: "string", required: true }, muteFor: { type: "string", required: true, description: "Duration to mute, e.g. 1_hour, 1_day, forever" } },
+        async execute(input, ctx) {
+            const { base, apiKey } = getConn(ctx);
+            const p = input;
+            return api(base, apiKey, "POST", `rmm_alerts/${p.id}/mute`, { id: p.id, mute_for: p.muteFor });
+        } });
+}

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

@@ -0,0 +1,125 @@
+const BASE = "https://api.tapfiliate.com/1.6";
+async function apiRequest(apiKey, 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: { "Api-Key": apiKey, "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(`Tapfiliate error ${res.status}: ${await res.text()}`);
+    const text = await res.text();
+    return text ? JSON.parse(text) : {};
+}
+export default function tapfiliate(rl) {
+    rl.setName("tapfiliate");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({ apiKey: { type: "string", required: true, description: "Tapfiliate API key", env: "TAPFILIATE_API_KEY" } });
+    const key = (ctx) => ctx.connection.config.apiKey;
+    // ── Affiliate ───────────────────────────────────────
+    rl.registerAction("affiliate.create", {
+        description: "Create an affiliate",
+        inputSchema: {
+            firstname: { type: "string", required: true }, lastname: { type: "string", required: true },
+            email: { type: "string", required: true }, companyName: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { firstname: p.firstname, lastname: p.lastname, email: p.email };
+            if (p.companyName)
+                body.company = { name: p.companyName };
+            return apiRequest(key(ctx), "POST", "/affiliates/", body);
+        },
+    });
+    rl.registerAction("affiliate.get", {
+        description: "Get an affiliate by ID",
+        inputSchema: { affiliateId: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(key(ctx), "GET", `/affiliates/${input.affiliateId}/`); },
+    });
+    rl.registerAction("affiliate.list", {
+        description: "List affiliates",
+        inputSchema: { limit: { type: "number", required: false }, email: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.email)
+                qs.email = p.email;
+            const data = (await apiRequest(key(ctx), "GET", "/affiliates/", undefined, qs));
+            return p.limit ? data.slice(0, p.limit) : data;
+        },
+    });
+    rl.registerAction("affiliate.delete", {
+        description: "Delete an affiliate",
+        inputSchema: { affiliateId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            await apiRequest(key(ctx), "DELETE", `/affiliates/${input.affiliateId}/`);
+            return { success: true };
+        },
+    });
+    // ── Affiliate Metadata ──────────────────────────────
+    rl.registerAction("affiliateMetadata.set", {
+        description: "Set metadata key-value on an affiliate",
+        inputSchema: { affiliateId: { type: "string", required: true }, key: { type: "string", required: true }, value: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(key(ctx), "PUT", `/affiliates/${p.affiliateId}/meta-data/${p.key}/`, { value: p.value });
+        },
+    });
+    rl.registerAction("affiliateMetadata.delete", {
+        description: "Delete a metadata key from an affiliate",
+        inputSchema: { affiliateId: { type: "string", required: true }, key: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            await apiRequest(key(ctx), "DELETE", `/affiliates/${p.affiliateId}/meta-data/${p.key}/`);
+            return { success: true };
+        },
+    });
+    // ── Program Affiliate ───────────────────────────────
+    rl.registerAction("programAffiliate.add", {
+        description: "Add an affiliate to a program",
+        inputSchema: { programId: { type: "string", required: true }, affiliateId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(key(ctx), "POST", `/programs/${p.programId}/affiliates/`, { affiliate: { id: p.affiliateId } });
+        },
+    });
+    rl.registerAction("programAffiliate.approve", {
+        description: "Approve an affiliate for a program",
+        inputSchema: { programId: { type: "string", required: true }, affiliateId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(key(ctx), "PUT", `/programs/${p.programId}/affiliates/${p.affiliateId}/approved/`);
+        },
+    });
+    rl.registerAction("programAffiliate.disapprove", {
+        description: "Disapprove an affiliate for a program",
+        inputSchema: { programId: { type: "string", required: true }, affiliateId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            await apiRequest(key(ctx), "DELETE", `/programs/${p.programId}/affiliates/${p.affiliateId}/approved/`);
+            return { success: true };
+        },
+    });
+    rl.registerAction("programAffiliate.get", {
+        description: "Get an affiliate in a program",
+        inputSchema: { programId: { type: "string", required: true }, affiliateId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(key(ctx), "GET", `/programs/${p.programId}/affiliates/${p.affiliateId}/`);
+        },
+    });
+    rl.registerAction("programAffiliate.list", {
+        description: "List affiliates in a program",
+        inputSchema: { programId: { type: "string", required: true }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const data = (await apiRequest(key(ctx), "GET", `/programs/${p.programId}/affiliates/`));
+            return p.limit ? data.slice(0, p.limit) : data;
+        },
+    });
+}

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

@@ -0,0 +1,233 @@
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    const baseUrl = (c.baseUrl || "https://api.telegram.org").replace(/\/$/, "");
+    return { baseUrl, token: c.accessToken };
+}
+async function apiRequest(conn, method, endpoint, body) {
+    const url = `${conn.baseUrl}/bot${conn.token}/${endpoint}`;
+    const init = { method, headers: { "Content-Type": "application/json" } };
+    if (body && Object.keys(body).length > 0)
+        init.body = JSON.stringify(body);
+    const res = await fetch(url, init);
+    if (!res.ok)
+        throw new Error(`Telegram error ${res.status}: ${await res.text()}`);
+    const data = (await res.json());
+    if (!data.ok)
+        throw new Error(`Telegram API error: ${JSON.stringify(data)}`);
+    return data.result;
+}
+export default function telegram(rl) {
+    rl.setName("telegram");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        accessToken: { type: "string", required: true, description: "Telegram Bot token", env: "TELEGRAM_BOT_TOKEN" },
+        baseUrl: { type: "string", required: false, description: "API base URL (default: https://api.telegram.org)", env: "TELEGRAM_BASE_URL" },
+    });
+    // ── Message ─────────────────────────────────────────
+    rl.registerAction("message.send", {
+        description: "Send a text message",
+        inputSchema: {
+            chatId: { type: "string", required: true },
+            text: { type: "string", required: true },
+            parseMode: { type: "string", required: false, description: "Markdown, MarkdownV2, or HTML" },
+            disableWebPagePreview: { type: "boolean", required: false },
+            disableNotification: { type: "boolean", required: false },
+            replyToMessageId: { type: "number", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { chat_id: p.chatId, text: p.text };
+            if (p.parseMode)
+                body.parse_mode = p.parseMode;
+            if (p.disableWebPagePreview)
+                body.disable_web_page_preview = true;
+            if (p.disableNotification)
+                body.disable_notification = true;
+            if (p.replyToMessageId)
+                body.reply_to_message_id = p.replyToMessageId;
+            return apiRequest(getConn(ctx), "POST", "sendMessage", body);
+        },
+    });
+    rl.registerAction("message.edit", {
+        description: "Edit a text message",
+        inputSchema: {
+            chatId: { type: "string", required: true },
+            messageId: { type: "number", required: true },
+            text: { type: "string", required: true },
+            parseMode: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { chat_id: p.chatId, message_id: p.messageId, text: p.text };
+            if (p.parseMode)
+                body.parse_mode = p.parseMode;
+            return apiRequest(getConn(ctx), "POST", "editMessageText", body);
+        },
+    });
+    rl.registerAction("message.delete", {
+        description: "Delete a message",
+        inputSchema: { chatId: { type: "string", required: true }, messageId: { type: "number", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(getConn(ctx), "POST", "deleteMessage", { chat_id: p.chatId, message_id: p.messageId });
+        },
+    });
+    rl.registerAction("message.pin", {
+        description: "Pin a message in a chat",
+        inputSchema: { chatId: { type: "string", required: true }, messageId: { type: "number", required: true }, disableNotification: { type: "boolean", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { chat_id: p.chatId, message_id: p.messageId };
+            if (p.disableNotification)
+                body.disable_notification = true;
+            return apiRequest(getConn(ctx), "POST", "pinChatMessage", body);
+        },
+    });
+    rl.registerAction("message.unpin", {
+        description: "Unpin a message in a chat",
+        inputSchema: { chatId: { type: "string", required: true }, messageId: { type: "number", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(getConn(ctx), "POST", "unpinChatMessage", { chat_id: p.chatId, message_id: p.messageId });
+        },
+    });
+    rl.registerAction("message.sendLocation", {
+        description: "Send a location",
+        inputSchema: { chatId: { type: "string", required: true }, latitude: { type: "number", required: true }, longitude: { type: "number", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(getConn(ctx), "POST", "sendLocation", { chat_id: p.chatId, latitude: p.latitude, longitude: p.longitude });
+        },
+    });
+    rl.registerAction("message.sendChatAction", {
+        description: "Send a chat action (typing, upload_photo, etc.)",
+        inputSchema: { chatId: { type: "string", required: true }, action: { type: "string", required: true, description: "typing, upload_photo, record_video, etc." } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(getConn(ctx), "POST", "sendChatAction", { chat_id: p.chatId, action: p.action });
+        },
+    });
+    rl.registerAction("message.sendPhoto", {
+        description: "Send a photo by URL",
+        inputSchema: { chatId: { type: "string", required: true }, photo: { type: "string", required: true, description: "Photo URL or file_id" }, caption: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { chat_id: p.chatId, photo: p.photo };
+            if (p.caption)
+                body.caption = p.caption;
+            return apiRequest(getConn(ctx), "POST", "sendPhoto", body);
+        },
+    });
+    rl.registerAction("message.sendDocument", {
+        description: "Send a document by URL",
+        inputSchema: { chatId: { type: "string", required: true }, document: { type: "string", required: true, description: "Document URL or file_id" }, caption: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { chat_id: p.chatId, document: p.document };
+            if (p.caption)
+                body.caption = p.caption;
+            return apiRequest(getConn(ctx), "POST", "sendDocument", body);
+        },
+    });
+    rl.registerAction("message.sendVideo", {
+        description: "Send a video by URL",
+        inputSchema: { chatId: { type: "string", required: true }, video: { type: "string", required: true, description: "Video URL or file_id" }, caption: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { chat_id: p.chatId, video: p.video };
+            if (p.caption)
+                body.caption = p.caption;
+            return apiRequest(getConn(ctx), "POST", "sendVideo", body);
+        },
+    });
+    rl.registerAction("message.sendSticker", {
+        description: "Send a sticker",
+        inputSchema: { chatId: { type: "string", required: true }, sticker: { type: "string", required: true, description: "Sticker URL or file_id" } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(getConn(ctx), "POST", "sendSticker", { chat_id: p.chatId, sticker: p.sticker });
+        },
+    });
+    rl.registerAction("message.sendAnimation", {
+        description: "Send a GIF/animation",
+        inputSchema: { chatId: { type: "string", required: true }, animation: { type: "string", required: true, description: "Animation URL or file_id" }, caption: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { chat_id: p.chatId, animation: p.animation };
+            if (p.caption)
+                body.caption = p.caption;
+            return apiRequest(getConn(ctx), "POST", "sendAnimation", body);
+        },
+    });
+    rl.registerAction("message.sendAudio", {
+        description: "Send audio by URL",
+        inputSchema: { chatId: { type: "string", required: true }, audio: { type: "string", required: true, description: "Audio URL or file_id" }, caption: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { chat_id: p.chatId, audio: p.audio };
+            if (p.caption)
+                body.caption = p.caption;
+            return apiRequest(getConn(ctx), "POST", "sendAudio", body);
+        },
+    });
+    // ── Chat ────────────────────────────────────────────
+    rl.registerAction("chat.get", {
+        description: "Get chat info",
+        inputSchema: { chatId: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(getConn(ctx), "POST", "getChat", { chat_id: input.chatId }); },
+    });
+    rl.registerAction("chat.getAdministrators", {
+        description: "Get chat administrators",
+        inputSchema: { chatId: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(getConn(ctx), "POST", "getChatAdministrators", { chat_id: input.chatId }); },
+    });
+    rl.registerAction("chat.getMember", {
+        description: "Get a chat member",
+        inputSchema: { chatId: { type: "string", required: true }, userId: { type: "number", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(getConn(ctx), "POST", "getChatMember", { chat_id: p.chatId, user_id: p.userId });
+        },
+    });
+    rl.registerAction("chat.leave", {
+        description: "Leave a chat",
+        inputSchema: { chatId: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(getConn(ctx), "POST", "leaveChat", { chat_id: input.chatId }); },
+    });
+    rl.registerAction("chat.setDescription", {
+        description: "Set chat description",
+        inputSchema: { chatId: { type: "string", required: true }, description: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(getConn(ctx), "POST", "setChatDescription", { chat_id: p.chatId, description: p.description });
+        },
+    });
+    rl.registerAction("chat.setTitle", {
+        description: "Set chat title",
+        inputSchema: { chatId: { type: "string", required: true }, title: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(getConn(ctx), "POST", "setChatTitle", { chat_id: p.chatId, title: p.title });
+        },
+    });
+    // ── Callback ────────────────────────────────────────
+    rl.registerAction("callback.answer", {
+        description: "Answer a callback query",
+        inputSchema: { callbackQueryId: { type: "string", required: true }, text: { type: "string", required: false }, showAlert: { type: "boolean", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { callback_query_id: p.callbackQueryId };
+            if (p.text)
+                body.text = p.text;
+            if (p.showAlert)
+                body.show_alert = true;
+            return apiRequest(getConn(ctx), "POST", "answerCallbackQuery", body);
+        },
+    });
+    // ── File ────────────────────────────────────────────
+    rl.registerAction("file.get", {
+        description: "Get file metadata (use result.file_path to download)",
+        inputSchema: { fileId: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(getConn(ctx), "POST", "getFile", { file_id: input.fileId }); },
+    });
+}