runline 0.1.0

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

@@ -0,0 +1,80 @@
+const BASE = "https://api.getvero.com/api/v2";
+async function apiRequest(token, method, endpoint, body) {
+    const form = new URLSearchParams();
+    form.set("auth_token", token);
+    for (const [k, v] of Object.entries(body)) {
+        if (v !== undefined && v !== null)
+            form.set(k, typeof v === "object" ? JSON.stringify(v) : String(v));
+    }
+    const res = await fetch(`${BASE}${endpoint}`, { method, headers: { "Content-Type": "application/x-www-form-urlencoded" }, body: form });
+    if (!res.ok)
+        throw new Error(`Vero error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+export default function vero(rl) {
+    rl.setName("vero");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({ authToken: { type: "string", required: true, description: "Vero auth token", env: "VERO_AUTH_TOKEN" } });
+    const key = (ctx) => ctx.connection.config.authToken;
+    rl.registerAction("user.create", {
+        description: "Create/identify a user",
+        inputSchema: { id: { type: "string", required: true }, email: { type: "string", required: false }, data: { type: "object", required: false, description: "Custom attributes" } },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { id: p.id };
+            if (p.email)
+                body.email = p.email;
+            if (p.data)
+                body.data = p.data;
+            return apiRequest(key(ctx), "POST", "/users/track", body);
+        },
+    });
+    rl.registerAction("user.alias", {
+        description: "Alias (re-identify) a user",
+        inputSchema: { id: { type: "string", required: true }, newId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(key(ctx), "PUT", "/users/reidentify", { id: p.id, new_id: p.newId });
+        },
+    });
+    for (const op of ["unsubscribe", "resubscribe", "delete"]) {
+        rl.registerAction(`user.${op}`, {
+            description: `${op.charAt(0).toUpperCase() + op.slice(1)} a user`,
+            inputSchema: { id: { type: "string", required: true } },
+            async execute(input, ctx) { return apiRequest(key(ctx), "POST", `/users/${op}`, { id: input.id }); },
+        });
+    }
+    rl.registerAction("user.addTags", {
+        description: "Add tags to a user",
+        inputSchema: { id: { type: "string", required: true }, tags: { type: "string", required: true, description: "Comma-separated tags" } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(key(ctx), "PUT", "/users/tags/edit", { id: p.id, add: JSON.stringify(p.tags.split(",").map(t => t.trim())) });
+        },
+    });
+    rl.registerAction("user.removeTags", {
+        description: "Remove tags from a user",
+        inputSchema: { id: { type: "string", required: true }, tags: { type: "string", required: true, description: "Comma-separated tags" } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(key(ctx), "PUT", "/users/tags/edit", { id: p.id, remove: JSON.stringify(p.tags.split(",").map(t => t.trim())) });
+        },
+    });
+    rl.registerAction("event.track", {
+        description: "Track an event",
+        inputSchema: {
+            id: { type: "string", required: true }, email: { type: "string", required: true },
+            eventName: { type: "string", required: true }, data: { type: "object", required: false },
+            extras: { type: "object", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { identity: { id: p.id, email: p.email }, event_name: p.eventName, email: p.email };
+            if (p.data)
+                body.data = JSON.stringify(p.data);
+            if (p.extras)
+                body.extras = JSON.stringify(p.extras);
+            return apiRequest(key(ctx), "POST", "/events/track", body);
+        },
+    });
+}

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

@@ -0,0 +1,42 @@
+export default function vonage(rl) {
+    rl.setName("vonage");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: { type: "string", required: true, description: "Vonage API key", env: "VONAGE_API_KEY" },
+        apiSecret: { type: "string", required: true, description: "Vonage API secret", env: "VONAGE_API_SECRET" },
+    });
+    rl.registerAction("sms.send", {
+        description: "Send an SMS",
+        inputSchema: {
+            from: { type: "string", required: true, description: "Sender name or number" },
+            to: { type: "string", required: true, description: "Recipient number in E.164 format" },
+            text: { type: "string", required: true, description: "Message text" },
+            ttl: { type: "number", required: false, description: "Time-to-live in minutes (default 4320 = 72h)" },
+            callback: { type: "string", required: false, description: "Webhook URL for delivery receipt" },
+        },
+        async execute(input, ctx) {
+            const c = ctx.connection.config;
+            const p = input;
+            const form = new URLSearchParams();
+            form.set("api_key", c.apiKey);
+            form.set("api_secret", c.apiSecret);
+            form.set("from", p.from);
+            form.set("to", p.to);
+            form.set("text", p.text);
+            form.set("type", "text");
+            if (p.ttl)
+                form.set("ttl", String(p.ttl * 60000));
+            if (p.callback)
+                form.set("callback", p.callback);
+            const res = await fetch("https://rest.nexmo.com/sms/json", {
+                method: "POST",
+                headers: { "Content-Type": "application/x-www-form-urlencoded" },
+                body: form,
+            });
+            if (!res.ok)
+                throw new Error(`Vonage error ${res.status}: ${await res.text()}`);
+            const data = (await res.json());
+            return data.messages;
+        },
+    });
+}

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

@@ -0,0 +1,91 @@
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    return { url: c.url.replace(/\/$/, ""), token: c.token };
+}
+async function api(conn, method, endpoint, body) {
+    const init = { method, headers: { Authorization: `Bearer ${conn.token}`, "Content-Type": "application/json", Accept: "application/json" } };
+    if (body && Object.keys(body).length > 0)
+        init.body = JSON.stringify(body);
+    const res = await fetch(`${conn.url}/api/${endpoint}`, init);
+    if (!res.ok)
+        throw new Error(`Wekan error ${res.status}: ${await res.text()}`);
+    const text = await res.text();
+    return text ? JSON.parse(text) : {};
+}
+export default function wekan(rl) {
+    rl.setName("wekan");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        url: { type: "string", required: true, description: "Wekan server URL", env: "WEKAN_URL" },
+        token: { type: "string", required: true, description: "Wekan API token", env: "WEKAN_TOKEN" },
+    });
+    // ── Board ───────────────────────────────────────────
+    rl.registerAction("board.create", { description: "Create a board", inputSchema: { title: { type: "string", required: true }, owner: { type: "string", required: true } },
+        async execute(input, ctx) { return api(getConn(ctx), "POST", "boards", input); } });
+    rl.registerAction("board.get", { description: "Get a board", inputSchema: { boardId: { type: "string", required: true } },
+        async execute(input, ctx) { return api(getConn(ctx), "GET", `boards/${input.boardId}`); } });
+    rl.registerAction("board.list", { description: "List boards for a user", inputSchema: { userId: { type: "string", required: true }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const data = (await api(getConn(ctx), "GET", `users/${p.userId}/boards`));
+            return p.limit ? data.slice(0, p.limit) : data;
+        } });
+    rl.registerAction("board.delete", { description: "Delete a board", inputSchema: { boardId: { type: "string", required: true } },
+        async execute(input, ctx) { return api(getConn(ctx), "DELETE", `boards/${input.boardId}`); } });
+    // ── List ────────────────────────────────────────────
+    rl.registerAction("list.create", { description: "Create a list on a board", inputSchema: { boardId: { type: "string", required: true }, title: { type: "string", required: true } },
+        async execute(input, ctx) { const p = input; return api(getConn(ctx), "POST", `boards/${p.boardId}/lists`, { title: p.title }); } });
+    rl.registerAction("list.get", { description: "Get a list", inputSchema: { boardId: { type: "string", required: true }, listId: { type: "string", required: true } },
+        async execute(input, ctx) { const p = input; return api(getConn(ctx), "GET", `boards/${p.boardId}/lists/${p.listId}`); } });
+    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 api(getConn(ctx), "GET", `boards/${p.boardId}/lists`));
+            return p.limit ? data.slice(0, p.limit) : data;
+        } });
+    rl.registerAction("list.delete", { description: "Delete a list", inputSchema: { boardId: { type: "string", required: true }, listId: { type: "string", required: true } },
+        async execute(input, ctx) { const p = input; return api(getConn(ctx), "DELETE", `boards/${p.boardId}/lists/${p.listId}`); } });
+    // ── Card ────────────────────────────────────────────
+    rl.registerAction("card.create", { description: "Create a card", inputSchema: { boardId: { type: "string", required: true }, listId: { type: "string", required: true }, title: { type: "string", required: true }, swimlaneId: { type: "string", required: true }, authorId: { type: "string", required: true }, description: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { boardId, listId, ...body } = input;
+            return api(getConn(ctx), "POST", `boards/${boardId}/lists/${listId}/cards`, body);
+        } });
+    rl.registerAction("card.get", { description: "Get a card", inputSchema: { boardId: { type: "string", required: true }, listId: { type: "string", required: true }, cardId: { type: "string", required: true } },
+        async execute(input, ctx) { const p = input; return api(getConn(ctx), "GET", `boards/${p.boardId}/lists/${p.listId}/cards/${p.cardId}`); } });
+    rl.registerAction("card.list", { description: "List cards in a list", inputSchema: { boardId: { type: "string", required: true }, listId: { type: "string", required: true }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const data = (await api(getConn(ctx), "GET", `boards/${p.boardId}/lists/${p.listId}/cards`));
+            return p.limit ? data.slice(0, p.limit) : data;
+        } });
+    rl.registerAction("card.update", { description: "Update a card", inputSchema: { boardId: { type: "string", required: true }, listId: { type: "string", required: true }, cardId: { type: "string", required: true }, data: { type: "object", required: true } },
+        async execute(input, ctx) { const p = input; return api(getConn(ctx), "PUT", `boards/${p.boardId}/lists/${p.listId}/cards/${p.cardId}`, p.data); } });
+    rl.registerAction("card.delete", { description: "Delete a card", inputSchema: { boardId: { type: "string", required: true }, listId: { type: "string", required: true }, cardId: { type: "string", required: true } },
+        async execute(input, ctx) { const p = input; return api(getConn(ctx), "DELETE", `boards/${p.boardId}/lists/${p.listId}/cards/${p.cardId}`); } });
+    // ── Card Comment ────────────────────────────────────
+    rl.registerAction("cardComment.create", { description: "Add a comment to a card", inputSchema: { boardId: { type: "string", required: true }, cardId: { type: "string", required: true }, authorId: { type: "string", required: true }, comment: { type: "string", required: true } },
+        async execute(input, ctx) { const p = input; return api(getConn(ctx), "POST", `boards/${p.boardId}/cards/${p.cardId}/comments`, { authorId: p.authorId, comment: p.comment }); } });
+    rl.registerAction("cardComment.get", { description: "Get a comment", inputSchema: { boardId: { type: "string", required: true }, cardId: { type: "string", required: true }, commentId: { type: "string", required: true } },
+        async execute(input, ctx) { const p = input; return api(getConn(ctx), "GET", `boards/${p.boardId}/cards/${p.cardId}/comments/${p.commentId}`); } });
+    rl.registerAction("cardComment.list", { description: "List comments on a card", inputSchema: { boardId: { type: "string", required: true }, cardId: { type: "string", required: true } },
+        async execute(input, ctx) { const p = input; return api(getConn(ctx), "GET", `boards/${p.boardId}/cards/${p.cardId}/comments`); } });
+    rl.registerAction("cardComment.delete", { description: "Delete a comment", inputSchema: { boardId: { type: "string", required: true }, cardId: { type: "string", required: true }, commentId: { type: "string", required: true } },
+        async execute(input, ctx) { const p = input; return api(getConn(ctx), "DELETE", `boards/${p.boardId}/cards/${p.cardId}/comments/${p.commentId}`); } });
+    // ── Checklist ───────────────────────────────────────
+    rl.registerAction("checklist.create", { description: "Create a checklist on a card", inputSchema: { boardId: { type: "string", required: true }, cardId: { type: "string", required: true }, title: { type: "string", required: true }, items: { type: "object", required: false, description: "Array of item titles" } },
+        async execute(input, ctx) { const p = input; return api(getConn(ctx), "POST", `boards/${p.boardId}/cards/${p.cardId}/checklists`, { title: p.title, items: p.items }); } });
+    rl.registerAction("checklist.get", { description: "Get a checklist", inputSchema: { boardId: { type: "string", required: true }, cardId: { type: "string", required: true }, checklistId: { type: "string", required: true } },
+        async execute(input, ctx) { const p = input; return api(getConn(ctx), "GET", `boards/${p.boardId}/cards/${p.cardId}/checklists/${p.checklistId}`); } });
+    rl.registerAction("checklist.list", { description: "List checklists on a card", inputSchema: { boardId: { type: "string", required: true }, cardId: { type: "string", required: true } },
+        async execute(input, ctx) { const p = input; return api(getConn(ctx), "GET", `boards/${p.boardId}/cards/${p.cardId}/checklists`); } });
+    rl.registerAction("checklist.delete", { description: "Delete a checklist", inputSchema: { boardId: { type: "string", required: true }, cardId: { type: "string", required: true }, checklistId: { type: "string", required: true } },
+        async execute(input, ctx) { const p = input; return api(getConn(ctx), "DELETE", `boards/${p.boardId}/cards/${p.cardId}/checklists/${p.checklistId}`); } });
+    // ── Checklist Item ──────────────────────────────────
+    rl.registerAction("checklistItem.get", { description: "Get a checklist item", inputSchema: { boardId: { type: "string", required: true }, cardId: { type: "string", required: true }, checklistId: { type: "string", required: true }, itemId: { type: "string", required: true } },
+        async execute(input, ctx) { const p = input; return api(getConn(ctx), "GET", `boards/${p.boardId}/cards/${p.cardId}/checklists/${p.checklistId}/items/${p.itemId}`); } });
+    rl.registerAction("checklistItem.update", { description: "Update a checklist item", inputSchema: { boardId: { type: "string", required: true }, cardId: { type: "string", required: true }, checklistId: { type: "string", required: true }, itemId: { type: "string", required: true }, data: { type: "object", required: true } },
+        async execute(input, ctx) { const p = input; return api(getConn(ctx), "PUT", `boards/${p.boardId}/cards/${p.cardId}/checklists/${p.checklistId}/items/${p.itemId}`, p.data); } });
+    rl.registerAction("checklistItem.delete", { description: "Delete a checklist item", inputSchema: { boardId: { type: "string", required: true }, cardId: { type: "string", required: true }, checklistId: { type: "string", required: true }, itemId: { type: "string", required: true } },
+        async execute(input, ctx) { const p = input; return api(getConn(ctx), "DELETE", `boards/${p.boardId}/cards/${p.cardId}/checklists/${p.checklistId}/items/${p.itemId}`); } });
+}

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

@@ -0,0 +1,92 @@
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    return { url: c.url.replace(/\/$/, ""), consumerKey: c.consumerKey, consumerSecret: c.consumerSecret };
+}
+async function apiRequest(conn, method, endpoint, body, qs) {
+    const url = new URL(`${conn.url}/wp-json/wc/v3${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: `Basic ${btoa(`${conn.consumerKey}:${conn.consumerSecret}`)}`, "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(`WooCommerce error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+function registerCrud(rl, resource, plural, conn, createSchema) {
+    rl.registerAction(`${resource}.create`, {
+        description: `Create a ${resource}`,
+        inputSchema: createSchema,
+        async execute(input, ctx) { return apiRequest(conn(ctx), "POST", `/${plural}`, input); },
+    });
+    rl.registerAction(`${resource}.get`, {
+        description: `Get a ${resource} by ID`,
+        inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(conn(ctx), "GET", `/${plural}/${input.id}`); },
+    });
+    rl.registerAction(`${resource}.list`, {
+        description: `List ${plural}`,
+        inputSchema: { limit: { type: "number", required: false }, search: { type: "string", required: false }, status: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.limit)
+                qs.per_page = p.limit;
+            if (p.search)
+                qs.search = p.search;
+            if (p.status)
+                qs.status = p.status;
+            return apiRequest(conn(ctx), "GET", `/${plural}`, undefined, qs);
+        },
+    });
+    rl.registerAction(`${resource}.update`, {
+        description: `Update a ${resource}`,
+        inputSchema: { id: { type: "string", required: true }, data: { type: "object", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(conn(ctx), "PUT", `/${plural}/${p.id}`, p.data);
+        },
+    });
+    rl.registerAction(`${resource}.delete`, {
+        description: `Delete a ${resource}`,
+        inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) {
+            return apiRequest(conn(ctx), "DELETE", `/${plural}/${input.id}`, undefined, { force: "true" });
+        },
+    });
+}
+export default function woocommerce(rl) {
+    rl.setName("woocommerce");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        url: { type: "string", required: true, description: "WooCommerce store URL", env: "WOOCOMMERCE_URL" },
+        consumerKey: { type: "string", required: true, description: "WooCommerce consumer key", env: "WOOCOMMERCE_CONSUMER_KEY" },
+        consumerSecret: { type: "string", required: true, description: "WooCommerce consumer secret", env: "WOOCOMMERCE_CONSUMER_SECRET" },
+    });
+    registerCrud(rl, "product", "products", getConn, {
+        name: { type: "string", required: true },
+        type: { type: "string", required: false, description: "simple, grouped, external, variable" },
+        regular_price: { type: "string", required: false },
+        description: { type: "string", required: false },
+        sku: { type: "string", required: false },
+    });
+    registerCrud(rl, "order", "orders", getConn, {
+        status: { type: "string", required: false, description: "pending, processing, on-hold, completed, cancelled, refunded, failed" },
+        customer_id: { type: "number", required: false },
+        line_items: { type: "object", required: false, description: "Array of { product_id, quantity }" },
+        payment_method: { type: "string", required: false },
+    });
+    registerCrud(rl, "customer", "customers", getConn, {
+        email: { type: "string", required: true },
+        first_name: { type: "string", required: false },
+        last_name: { type: "string", required: false },
+    });
+}

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

@@ -0,0 +1,121 @@
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    return { url: c.url.replace(/\/$/, ""), username: c.username, password: c.password };
+}
+async function apiRequest(conn, method, endpoint, body, qs) {
+    const url = new URL(`${conn.url}/wp-json/wp/v2${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: `Basic ${btoa(`${conn.username}:${conn.password}`)}`, "Content-Type": "application/json", Accept: "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(`WordPress error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+function registerContentCrud(rl, resource, plural, conn) {
+    rl.registerAction(`${resource}.create`, {
+        description: `Create a ${resource}`,
+        inputSchema: { title: { type: "string", required: true }, content: { type: "string", required: false }, status: { type: "string", required: false, description: "publish, draft, pending, private" }, slug: { type: "string", required: false } },
+        async execute(input, ctx) { return apiRequest(conn(ctx), "POST", `/${plural}`, input); },
+    });
+    rl.registerAction(`${resource}.get`, {
+        description: `Get a ${resource} by ID`,
+        inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(conn(ctx), "GET", `/${plural}/${input.id}`); },
+    });
+    rl.registerAction(`${resource}.list`, {
+        description: `List ${plural}`,
+        inputSchema: { limit: { type: "number", required: false }, search: { type: "string", required: false }, status: { type: "string", required: false }, orderby: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.limit)
+                qs.per_page = p.limit;
+            if (p.search)
+                qs.search = p.search;
+            if (p.status)
+                qs.status = p.status;
+            if (p.orderby)
+                qs.orderby = p.orderby;
+            return apiRequest(conn(ctx), "GET", `/${plural}`, undefined, qs);
+        },
+    });
+    rl.registerAction(`${resource}.update`, {
+        description: `Update a ${resource}`,
+        inputSchema: { id: { type: "string", required: true }, title: { type: "string", required: false }, content: { type: "string", required: false }, status: { type: "string", required: false }, slug: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { id, ...fields } = input;
+            return apiRequest(conn(ctx), "POST", `/${plural}/${id}`, fields);
+        },
+    });
+    rl.registerAction(`${resource}.delete`, {
+        description: `Delete a ${resource}`,
+        inputSchema: { id: { type: "string", required: true }, force: { type: "boolean", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const qs = {};
+            if (p.force)
+                qs.force = "true";
+            return apiRequest(conn(ctx), "DELETE", `/${plural}/${p.id}`, undefined, qs);
+        },
+    });
+}
+export default function wordpress(rl) {
+    rl.setName("wordpress");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        url: { type: "string", required: true, description: "WordPress site URL", env: "WORDPRESS_URL" },
+        username: { type: "string", required: true, description: "WordPress username", env: "WORDPRESS_USERNAME" },
+        password: { type: "string", required: true, description: "WordPress application password", env: "WORDPRESS_PASSWORD" },
+    });
+    registerContentCrud(rl, "post", "posts", getConn);
+    registerContentCrud(rl, "page", "pages", getConn);
+    // ── User ────────────────────────────────────────────
+    rl.registerAction("user.create", {
+        description: "Create a user",
+        inputSchema: { username: { type: "string", required: true }, email: { type: "string", required: true }, password: { type: "string", required: true }, name: { type: "string", required: false } },
+        async execute(input, ctx) { return apiRequest(getConn(ctx), "POST", "/users", input); },
+    });
+    rl.registerAction("user.get", {
+        description: "Get a user by ID",
+        inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(getConn(ctx), "GET", `/users/${input.id}`); },
+    });
+    rl.registerAction("user.list", {
+        description: "List users",
+        inputSchema: { limit: { type: "number", required: false }, search: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.limit)
+                qs.per_page = p.limit;
+            if (p.search)
+                qs.search = p.search;
+            return apiRequest(getConn(ctx), "GET", "/users", undefined, qs);
+        },
+    });
+    rl.registerAction("user.update", {
+        description: "Update a user",
+        inputSchema: { id: { type: "string", required: true }, name: { type: "string", required: false }, email: { type: "string", required: false }, description: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { id, ...fields } = input;
+            return apiRequest(getConn(ctx), "POST", `/users/${id}`, fields);
+        },
+    });
+    rl.registerAction("user.delete", {
+        description: "Delete the current user",
+        inputSchema: { reassign: { type: "string", required: true, description: "User ID to reassign content to" } },
+        async execute(input, ctx) {
+            return apiRequest(getConn(ctx), "DELETE", "/users/me", undefined, { reassign: input.reassign, force: "true" });
+        },
+    });
+}

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

@@ -0,0 +1,136 @@
+const BASE = "https://api.xero.com/api.xro/2.0";
+function getConn(ctx) {
+    return { accessToken: ctx.connection.config.accessToken, tenantId: ctx.connection.config.tenantId };
+}
+async function api(conn, 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 ${conn.accessToken}`, "Xero-tenant-id": conn.tenantId, "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(`Xero error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+export default function xero(rl) {
+    rl.setName("xero");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        accessToken: { type: "string", required: true, description: "Xero OAuth2 access token", env: "XERO_ACCESS_TOKEN" },
+        tenantId: { type: "string", required: true, description: "Xero tenant/organization ID", env: "XERO_TENANT_ID" },
+    });
+    // ── Invoice ─────────────────────────────────────────
+    rl.registerAction("invoice.create", {
+        description: "Create an invoice",
+        inputSchema: {
+            Type: { type: "string", required: true, description: "ACCREC (sales) or ACCPAY (bills)" },
+            ContactID: { type: "string", required: true },
+            LineItems: { type: "object", required: false, description: "Array of line items" },
+            Status: { type: "string", required: false, description: "DRAFT, SUBMITTED, AUTHORISED" },
+            Date: { type: "string", required: false },
+            DueDate: { type: "string", required: false },
+            Reference: { type: "string", required: false },
+            CurrencyCode: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { Type: p.Type, Contact: { ContactID: p.ContactID } };
+            if (p.LineItems)
+                body.LineItems = p.LineItems;
+            if (p.Status)
+                body.Status = p.Status;
+            if (p.Date)
+                body.Date = p.Date;
+            if (p.DueDate)
+                body.DueDate = p.DueDate;
+            if (p.Reference)
+                body.Reference = p.Reference;
+            if (p.CurrencyCode)
+                body.CurrencyCode = p.CurrencyCode;
+            const data = (await api(getConn(ctx), "POST", "/Invoices", body));
+            return data.Invoices;
+        },
+    });
+    rl.registerAction("invoice.get", {
+        description: "Get an invoice by ID",
+        inputSchema: { invoiceId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = (await api(getConn(ctx), "GET", `/Invoices/${input.invoiceId}`));
+            return data.Invoices;
+        },
+    });
+    rl.registerAction("invoice.list", {
+        description: "List invoices",
+        inputSchema: { limit: { type: "number", required: false }, statuses: { type: "string", required: false, description: "Comma-separated statuses" }, where: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.statuses)
+                qs.statuses = p.statuses;
+            if (p.where)
+                qs.where = p.where;
+            const data = (await api(getConn(ctx), "GET", "/Invoices", undefined, qs));
+            const invoices = data.Invoices;
+            return p.limit ? invoices.slice(0, p.limit) : invoices;
+        },
+    });
+    rl.registerAction("invoice.update", {
+        description: "Update an invoice",
+        inputSchema: { invoiceId: { type: "string", required: true }, data: { type: "object", required: true, description: "Fields to update (Xero API format)" } },
+        async execute(input, ctx) {
+            const p = input;
+            const result = (await api(getConn(ctx), "POST", `/Invoices/${p.invoiceId}`, p.data));
+            return result.Invoices;
+        },
+    });
+    // ── Contact ─────────────────────────────────────────
+    rl.registerAction("contact.create", {
+        description: "Create a contact",
+        inputSchema: { Name: { type: "string", required: true }, EmailAddress: { type: "string", required: false }, FirstName: { type: "string", required: false }, LastName: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { Contacts: [p] };
+            const data = (await api(getConn(ctx), "POST", "/Contacts", body));
+            return data.Contacts;
+        },
+    });
+    rl.registerAction("contact.get", {
+        description: "Get a contact by ID",
+        inputSchema: { contactId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = (await api(getConn(ctx), "GET", `/Contacts/${input.contactId}`));
+            return data.Contacts;
+        },
+    });
+    rl.registerAction("contact.list", {
+        description: "List contacts",
+        inputSchema: { limit: { type: "number", required: false }, where: { type: "string", required: false }, includeArchived: { type: "boolean", required: false } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.where)
+                qs.where = p.where;
+            if (p.includeArchived)
+                qs.includeArchived = "true";
+            const data = (await api(getConn(ctx), "GET", "/Contacts", undefined, qs));
+            const contacts = data.Contacts;
+            return p.limit ? contacts.slice(0, p.limit) : contacts;
+        },
+    });
+    rl.registerAction("contact.update", {
+        description: "Update a contact",
+        inputSchema: { contactId: { type: "string", required: true }, data: { type: "object", required: true, description: "Fields to update (Xero API format)" } },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { Contacts: [p.data] };
+            const result = (await api(getConn(ctx), "POST", `/Contacts/${p.contactId}`, body));
+            return result.Contacts;
+        },
+    });
+}

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

@@ -0,0 +1,56 @@
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    return { url: c.url.replace(/\/$/, ""), signature: c.signature };
+}
+async function apiRequest(conn, qs) {
+    const url = new URL(`${conn.url}/yourls-api.php`);
+    qs.signature = conn.signature;
+    qs.format = "json";
+    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());
+    if (!res.ok)
+        throw new Error(`Yourls error ${res.status}: ${await res.text()}`);
+    const data = (await res.json());
+    if (data.status === "fail")
+        throw new Error(`Yourls error: ${data.message}`);
+    return data;
+}
+export default function yourls(rl) {
+    rl.setName("yourls");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        url: { type: "string", required: true, description: "Yourls installation URL", env: "YOURLS_URL" },
+        signature: { type: "string", required: true, description: "Yourls signature token", env: "YOURLS_SIGNATURE" },
+    });
+    rl.registerAction("url.shorten", {
+        description: "Shorten a URL",
+        inputSchema: { url: { type: "string", required: true }, keyword: { type: "string", required: false, description: "Custom short URL keyword" }, title: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const qs = { action: "shorturl", url: p.url };
+            if (p.keyword)
+                qs.keyword = p.keyword;
+            if (p.title)
+                qs.title = p.title;
+            return apiRequest(getConn(ctx), qs);
+        },
+    });
+    rl.registerAction("url.expand", {
+        description: "Expand a short URL to its original",
+        inputSchema: { shortUrl: { type: "string", required: true } },
+        async execute(input, ctx) {
+            return apiRequest(getConn(ctx), { action: "expand", shorturl: input.shortUrl });
+        },
+    });
+    rl.registerAction("url.stats", {
+        description: "Get stats for a short URL",
+        inputSchema: { shortUrl: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = (await apiRequest(getConn(ctx), { action: "url-stats", shorturl: input.shortUrl }));
+            return data.link;
+        },
+    });
+}