runline 0.1.0

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

@@ -0,0 +1,231 @@
+async function gql(token, query, variables = {}) {
+    const res = await fetch("https://api.monday.com/v2/", {
+        method: "POST",
+        headers: { Authorization: token, "API-Version": "2023-10", "Content-Type": "application/json" },
+        body: JSON.stringify({ query, variables }),
+    });
+    if (!res.ok)
+        throw new Error(`Monday.com API error ${res.status}: ${await res.text()}`);
+    const data = (await res.json());
+    if (data.errors)
+        throw new Error(`Monday.com GraphQL errors: ${JSON.stringify(data.errors)}`);
+    return data.data;
+}
+export default function monday(rl) {
+    rl.setName("monday");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiToken: { type: "string", required: true, description: "Monday.com API token (v2)", env: "MONDAY_API_TOKEN" },
+    });
+    const tok = (ctx) => ctx.connection.config.apiToken;
+    // ── Board ───────────────────────────────────────────
+    rl.registerAction("board.create", {
+        description: "Create a board",
+        inputSchema: {
+            name: { type: "string", required: true },
+            kind: { type: "string", required: true, description: "public, private, or share" },
+            templateId: { type: "number", required: false },
+        },
+        async execute(input, ctx) {
+            const { name, kind, templateId } = input;
+            const vars = { name, kind };
+            if (templateId)
+                vars.templateId = templateId;
+            const data = await gql(tok(ctx), `mutation ($name: String!, $kind: BoardKind!, $templateId: ID) { create_board (board_name: $name, board_kind: $kind, template_id: $templateId) { id } }`, vars);
+            return data.create_board;
+        },
+    });
+    rl.registerAction("board.archive", {
+        description: "Archive a board",
+        inputSchema: { boardId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = await gql(tok(ctx), `mutation ($id: ID!) { archive_board (board_id: $id) { id } }`, { id: input.boardId });
+            return data.archive_board;
+        },
+    });
+    rl.registerAction("board.get", {
+        description: "Get a board by ID",
+        inputSchema: { boardId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = await gql(tok(ctx), `query ($id: [ID!]) { boards (ids: $id) { id name description state board_folder_id board_kind owners { id } } }`, { id: input.boardId });
+            return data.boards?.[0];
+        },
+    });
+    rl.registerAction("board.list", {
+        description: "List boards",
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const { limit } = (input ?? {});
+            const data = await gql(tok(ctx), `query ($limit: Int) { boards (limit: $limit) { id name description state board_folder_id board_kind owners { id } } }`, limit ? { limit } : {});
+            return data.boards;
+        },
+    });
+    // ── Board Column ────────────────────────────────────
+    rl.registerAction("boardColumn.create", {
+        description: "Create a column on a board",
+        inputSchema: {
+            boardId: { type: "string", required: true },
+            title: { type: "string", required: true },
+            columnType: { type: "string", required: true, description: "Column type (status, text, numbers, date, etc.) in snake_case" },
+            defaults: { type: "string", required: false, description: "Default values as JSON string" },
+        },
+        async execute(input, ctx) {
+            const { boardId, title, columnType, defaults } = input;
+            const vars = { boardId, title, columnType };
+            if (defaults)
+                vars.defaults = JSON.stringify(JSON.parse(defaults));
+            const data = await gql(tok(ctx), `mutation ($boardId: ID!, $title: String!, $columnType: ColumnType!, $defaults: JSON) { create_column (board_id: $boardId, title: $title, column_type: $columnType, defaults: $defaults) { id } }`, vars);
+            return data.create_column;
+        },
+    });
+    rl.registerAction("boardColumn.list", {
+        description: "List columns on a board",
+        inputSchema: { boardId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = await gql(tok(ctx), `query ($boardId: [ID!]) { boards (ids: $boardId) { columns { id title type settings_str archived } } }`, { boardId: input.boardId });
+            return data.boards?.[0]?.columns;
+        },
+    });
+    // ── Board Group ─────────────────────────────────────
+    rl.registerAction("boardGroup.create", {
+        description: "Create a group on a board",
+        inputSchema: { boardId: { type: "string", required: true }, name: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { boardId, name } = input;
+            const data = await gql(tok(ctx), `mutation ($boardId: ID!, $groupName: String!) { create_group (board_id: $boardId, group_name: $groupName) { id } }`, { boardId, groupName: name });
+            return data.create_group;
+        },
+    });
+    rl.registerAction("boardGroup.delete", {
+        description: "Delete a group from a board",
+        inputSchema: { boardId: { type: "string", required: true }, groupId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { boardId, groupId } = input;
+            const data = await gql(tok(ctx), `mutation ($boardId: ID!, $groupId: String!) { delete_group (board_id: $boardId, group_id: $groupId) { id } }`, { boardId, groupId });
+            return data.delete_group;
+        },
+    });
+    rl.registerAction("boardGroup.list", {
+        description: "List groups on a board",
+        inputSchema: { boardId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = await gql(tok(ctx), `query ($boardId: [ID!]) { boards (ids: $boardId) { id groups { id title color position archived } } }`, { boardId: input.boardId });
+            return data.boards?.[0]?.groups;
+        },
+    });
+    // ── Board Item ──────────────────────────────────────
+    rl.registerAction("boardItem.create", {
+        description: "Create an item in a board group",
+        inputSchema: {
+            boardId: { type: "string", required: true },
+            groupId: { type: "string", required: true },
+            name: { type: "string", required: true, description: "Item name" },
+            columnValues: { type: "string", required: false, description: "Column values as JSON string" },
+        },
+        async execute(input, ctx) {
+            const { boardId, groupId, name, columnValues } = input;
+            const vars = { boardId, groupId, itemName: name };
+            if (columnValues)
+                vars.columnValues = JSON.stringify(JSON.parse(columnValues));
+            const data = await gql(tok(ctx), `mutation ($boardId: ID!, $groupId: String!, $itemName: String!, $columnValues: JSON) { create_item (board_id: $boardId, group_id: $groupId, item_name: $itemName, column_values: $columnValues) { id } }`, vars);
+            return data.create_item;
+        },
+    });
+    rl.registerAction("boardItem.get", {
+        description: "Get item(s) by ID",
+        inputSchema: { itemIds: { type: "string", required: true, description: "Comma-separated item IDs" } },
+        async execute(input, ctx) {
+            const ids = input.itemIds.split(",").map((s) => s.trim());
+            const data = await gql(tok(ctx), `query ($itemId: [ID!]) { items (ids: $itemId) { id name created_at state column_values { id text type value column { title archived description settings_str } } } }`, { itemId: ids });
+            return data.items;
+        },
+    });
+    rl.registerAction("boardItem.list", {
+        description: "List items in a board group",
+        inputSchema: {
+            boardId: { type: "string", required: true },
+            groupId: { type: "string", required: true },
+            limit: { type: "number", required: false },
+        },
+        async execute(input, ctx) {
+            const { boardId, groupId, limit = 100 } = input;
+            const data = await gql(tok(ctx), `query ($boardId: [ID!], $groupId: [String], $limit: Int) { boards(ids: $boardId) { groups(ids: $groupId) { id items_page(limit: $limit) { cursor items { id name created_at state column_values { id text type value column { title archived description settings_str } } } } } } }`, { boardId, groupId, limit });
+            return data.boards?.[0]
+                ? data.boards[0].groups?.[0]
+                    ? data.boards[0].groups[0]
+                        ? data.boards[0].groups[0].items_page
+                            ? data.boards[0].groups[0].items_page
+                            : []
+                        : []
+                    : []
+                : [];
+        },
+    });
+    rl.registerAction("boardItem.delete", {
+        description: "Delete an item",
+        inputSchema: { itemId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = await gql(tok(ctx), `mutation ($itemId: ID!) { delete_item (item_id: $itemId) { id } }`, { itemId: input.itemId });
+            return data.delete_item;
+        },
+    });
+    rl.registerAction("boardItem.move", {
+        description: "Move an item to a different group",
+        inputSchema: { itemId: { type: "string", required: true }, groupId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { itemId, groupId } = input;
+            const data = await gql(tok(ctx), `mutation ($groupId: String!, $itemId: ID!) { move_item_to_group (group_id: $groupId, item_id: $itemId) { id } }`, { groupId, itemId });
+            return data.move_item_to_group;
+        },
+    });
+    rl.registerAction("boardItem.addUpdate", {
+        description: "Add an update (comment) to an item",
+        inputSchema: { itemId: { type: "string", required: true }, value: { type: "string", required: true, description: "Update body text" } },
+        async execute(input, ctx) {
+            const { itemId, value } = input;
+            const data = await gql(tok(ctx), `mutation ($itemId: ID!, $value: String!) { create_update (item_id: $itemId, body: $value) { id } }`, { itemId, value });
+            return data.create_update;
+        },
+    });
+    rl.registerAction("boardItem.changeColumnValue", {
+        description: "Change a single column value on an item",
+        inputSchema: {
+            boardId: { type: "string", required: true },
+            itemId: { type: "string", required: true },
+            columnId: { type: "string", required: true },
+            value: { type: "string", required: true, description: "Column value as JSON string" },
+        },
+        async execute(input, ctx) {
+            const { boardId, itemId, columnId, value } = input;
+            const data = await gql(tok(ctx), `mutation ($boardId: ID!, $itemId: ID!, $columnId: String!, $value: JSON!) { change_column_value (board_id: $boardId, item_id: $itemId, column_id: $columnId, value: $value) { id } }`, { boardId, itemId, columnId, value: JSON.stringify(JSON.parse(value)) });
+            return data.change_column_value;
+        },
+    });
+    rl.registerAction("boardItem.changeMultipleColumnValues", {
+        description: "Change multiple column values on an item",
+        inputSchema: {
+            boardId: { type: "string", required: true },
+            itemId: { type: "string", required: true },
+            columnValues: { type: "string", required: true, description: "Column values as JSON string" },
+        },
+        async execute(input, ctx) {
+            const { boardId, itemId, columnValues } = input;
+            const data = await gql(tok(ctx), `mutation ($boardId: ID!, $itemId: ID!, $columnValues: JSON!) { change_multiple_column_values (board_id: $boardId, item_id: $itemId, column_values: $columnValues) { id } }`, { boardId, itemId, columnValues: JSON.stringify(JSON.parse(columnValues)) });
+            return data.change_multiple_column_values;
+        },
+    });
+    rl.registerAction("boardItem.getByColumnValue", {
+        description: "Search items by column value",
+        inputSchema: {
+            boardId: { type: "string", required: true },
+            columnId: { type: "string", required: true },
+            columnValue: { type: "string", required: true },
+            limit: { type: "number", required: false },
+        },
+        async execute(input, ctx) {
+            const { boardId, columnId, columnValue, limit = 100 } = input;
+            const data = await gql(tok(ctx), `query ($boardId: ID!, $columnId: String!, $columnValue: String!, $limit: Int) { items_page_by_column_values (limit: $limit, board_id: $boardId, columns: [{column_id: $columnId, column_values: [$columnValue]}]) { cursor items { id name created_at state board { id } column_values { id text type value column { title archived description settings_str } } } } }`, { boardId, columnId, columnValue, limit });
+            return data.items_page_by_column_values?.items;
+        },
+    });
+}

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

@@ -0,0 +1,52 @@
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    const base = (c.url || "https://app.monicahq.com").replace(/\/$/, "");
+    return { url: base, token: c.apiToken };
+}
+async function api(conn, method, endpoint, body, qs) {
+    const url = new URL(`${conn.url}/api${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.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(`Monica CRM error ${res.status}: ${await res.text()}`);
+    if (res.status === 204)
+        return { success: true };
+    return res.json();
+}
+function registerCrud(rl, resource, plural, conn, createSchema) {
+    rl.registerAction(`${resource}.create`, { description: `Create a ${resource}`, inputSchema: createSchema,
+        async execute(input, ctx) { const data = (await api(conn(ctx), "POST", `/${plural}`, input)); return data.data; } });
+    rl.registerAction(`${resource}.get`, { description: `Get a ${resource}`, inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { const data = (await api(conn(ctx), "GET", `/${plural}/${input.id}`)); return data.data; } });
+    rl.registerAction(`${resource}.list`, { description: `List ${plural}`, inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) { const qs = { limit: (input ?? {}).limit ?? 100 }; const data = (await api(conn(ctx), "GET", `/${plural}`, undefined, qs)); return data.data; } });
+    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; const data = (await api(conn(ctx), "PUT", `/${plural}/${p.id}`, p.data)); return data.data; } });
+    rl.registerAction(`${resource}.delete`, { description: `Delete a ${resource}`, inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { await api(conn(ctx), "DELETE", `/${plural}/${input.id}`); return { success: true }; } });
+}
+export default function monicaCrm(rl) {
+    rl.setName("monicaCrm");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiToken: { type: "string", required: true, description: "Monica API token", env: "MONICA_API_TOKEN" },
+        url: { type: "string", required: false, description: "Monica URL (default: https://app.monicahq.com)", env: "MONICA_URL" },
+    });
+    registerCrud(rl, "contact", "contacts", getConn, { first_name: { type: "string", required: true }, last_name: { type: "string", required: false }, gender_id: { type: "number", required: false } });
+    registerCrud(rl, "activity", "activities", getConn, { summary: { type: "string", required: true }, description: { type: "string", required: false }, activity_type_id: { type: "number", required: false } });
+    registerCrud(rl, "note", "notes", getConn, { contact_id: { type: "number", required: true }, body: { type: "string", required: true } });
+    registerCrud(rl, "task", "tasks", getConn, { title: { type: "string", required: true }, contact_id: { type: "number", required: false } });
+    registerCrud(rl, "tag", "tags", getConn, { name: { type: "string", required: true } });
+    registerCrud(rl, "journalEntry", "journal", getConn, { title: { type: "string", required: true }, post: { type: "string", required: true } });
+    registerCrud(rl, "reminder", "reminders", getConn, { contact_id: { type: "number", required: true }, title: { type: "string", required: true }, initial_date: { type: "string", required: true }, frequency_type: { type: "string", required: true, description: "one_time, week, month, year" } });
+    registerCrud(rl, "call", "calls", getConn, { contact_id: { type: "number", required: true }, content: { type: "string", required: false }, called_at: { type: "string", required: false } });
+    registerCrud(rl, "conversation", "conversations", getConn, { contact_id: { type: "number", required: true }, contact_field_type_id: { type: "number", required: true }, happened_at: { type: "string", required: true } });
+}

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

@@ -0,0 +1,31 @@
+export default function msg91(rl) {
+    rl.setName("msg91");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        authkey: { type: "string", required: true, description: "MSG91 auth key", env: "MSG91_AUTHKEY" },
+    });
+    rl.registerAction("sms.send", {
+        description: "Send a transactional SMS via MSG91",
+        inputSchema: {
+            from: { type: "string", required: true, description: "Sender ID" },
+            to: { type: "string", required: true, description: "Recipient number with country code" },
+            message: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            const { from, to, message } = input;
+            const authkey = ctx.connection.config.authkey;
+            const url = new URL("https://api.msg91.com/api/sendhttp.php");
+            url.searchParams.set("authkey", authkey);
+            url.searchParams.set("route", "4");
+            url.searchParams.set("country", "0");
+            url.searchParams.set("sender", from);
+            url.searchParams.set("mobiles", to);
+            url.searchParams.set("message", message);
+            const res = await fetch(url.toString());
+            if (!res.ok)
+                throw new Error(`MSG91 API error ${res.status}: ${await res.text()}`);
+            const text = await res.text();
+            return { requestId: text };
+        },
+    });
+}

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

@@ -0,0 +1,146 @@
+const BASE_URL = "https://api.nasa.gov";
+async function apiRequest(apiKey, endpoint, qs = {}) {
+    const url = new URL(`${BASE_URL}${endpoint}`);
+    url.searchParams.set("api_key", apiKey);
+    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(`NASA API error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+function today() {
+    return new Date().toISOString().split("T")[0];
+}
+function formatDate(d) {
+    if (!d)
+        return undefined;
+    return String(d).split("T")[0];
+}
+export default function nasa(rl) {
+    rl.setName("nasa");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: { type: "string", required: true, description: "NASA API key (get one at https://api.nasa.gov)", env: "NASA_API_KEY" },
+    });
+    const key = (ctx) => ctx.connection.config.apiKey;
+    rl.registerAction("apod.get", {
+        description: "Get the Astronomy Picture of the Day (returns metadata; image URL in 'hdurl' field)",
+        inputSchema: { date: { type: "string", required: false, description: "Date (YYYY-MM-DD), defaults to today" } },
+        async execute(input, ctx) {
+            const qs = { date: formatDate(input?.date) ?? today() };
+            return apiRequest(key(ctx), "/planetary/apod", qs);
+        },
+    });
+    rl.registerAction("asteroidNeoFeed.get", {
+        description: "Get a list of asteroids based on closest approach date to Earth",
+        inputSchema: {
+            startDate: { type: "string", required: false, description: "Start date (YYYY-MM-DD), defaults to today" },
+            endDate: { type: "string", required: false, description: "End date (YYYY-MM-DD), defaults to today" },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {
+                start_date: formatDate(p.startDate) ?? today(),
+                end_date: formatDate(p.endDate) ?? today(),
+            };
+            const data = (await apiRequest(key(ctx), "/neo/rest/v1/feed", qs));
+            return data.near_earth_objects;
+        },
+    });
+    rl.registerAction("asteroidNeoLookup.get", {
+        description: "Look up an asteroid by its NASA SPK-ID",
+        inputSchema: {
+            asteroidId: { type: "string", required: true },
+            includeCloseApproachData: { type: "boolean", required: false, description: "Include close approach data (default false)" },
+        },
+        async execute(input, ctx) {
+            const { asteroidId, includeCloseApproachData } = input;
+            const data = (await apiRequest(key(ctx), `/neo/rest/v1/neo/${asteroidId}`));
+            if (!includeCloseApproachData)
+                delete data.close_approach_data;
+            return data;
+        },
+    });
+    rl.registerAction("asteroidNeoBrowse.list", {
+        description: "Browse the overall asteroid dataset",
+        inputSchema: { limit: { type: "number", required: false, description: "Max results (default 20)" } },
+        async execute(input, ctx) {
+            const qs = {};
+            if (input?.limit)
+                qs.size = input.limit;
+            const data = (await apiRequest(key(ctx), "/neo/rest/v1/neo/browse", qs));
+            return data.near_earth_objects;
+        },
+    });
+    // ── DONKI endpoints ─────────────────────────────────
+    const donkiEndpoints = [
+        { name: "coronalMassEjection", path: "/DONKI/CME", description: "DONKI Coronal Mass Ejection data" },
+        { name: "solarFlare", path: "/DONKI/FLR", description: "DONKI Solar Flare data" },
+        { name: "solarEnergeticParticle", path: "/DONKI/SEP", description: "DONKI Solar Energetic Particle data" },
+        { name: "magnetopauseCrossing", path: "/DONKI/MPC", description: "DONKI Magnetopause Crossing data" },
+        { name: "radiationBeltEnhancement", path: "/DONKI/RBE", description: "DONKI Radiation Belt Enhancement data" },
+        { name: "highSpeedStream", path: "/DONKI/HSS", description: "DONKI High Speed Stream data" },
+        { name: "wsaEnlilSimulation", path: "/DONKI/WSAEnlilSimulations", description: "DONKI WSA+Enlil Simulation data" },
+        { name: "notifications", path: "/DONKI/notifications", description: "DONKI Notifications data" },
+    ];
+    for (const ep of donkiEndpoints) {
+        rl.registerAction(`donki.${ep.name}`, {
+            description: ep.description,
+            inputSchema: {
+                startDate: { type: "string", required: false, description: "Start date (YYYY-MM-DD), defaults to 30 days ago" },
+                endDate: { type: "string", required: false, description: "End date (YYYY-MM-DD), defaults to today" },
+            },
+            async execute(input, ctx) {
+                const p = (input ?? {});
+                const qs = {};
+                if (p.startDate)
+                    qs.startDate = formatDate(p.startDate);
+                if (p.endDate)
+                    qs.endDate = formatDate(p.endDate);
+                return apiRequest(key(ctx), ep.path, qs);
+            },
+        });
+    }
+    rl.registerAction("donki.interplanetaryShock", {
+        description: "DONKI Interplanetary Shock data",
+        inputSchema: {
+            startDate: { type: "string", required: false },
+            endDate: { type: "string", required: false },
+            location: { type: "string", required: false, description: "ALL (default), earth, MESSENGER, STEREO A, STEREO B" },
+            catalog: { type: "string", required: false, description: "ALL (default), SWRC_CATALOG, WINSLOW_MESSENGER_ICME_CATALOG" },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.startDate)
+                qs.startDate = formatDate(p.startDate);
+            if (p.endDate)
+                qs.endDate = formatDate(p.endDate);
+            if (p.location)
+                qs.location = p.location;
+            if (p.catalog)
+                qs.catalog = p.catalog;
+            return apiRequest(key(ctx), "/DONKI/IPS", qs);
+        },
+    });
+    // ── Earth ───────────────────────────────────────────
+    rl.registerAction("earthAssets.get", {
+        description: "Get Earth asset metadata for a location",
+        inputSchema: {
+            lat: { type: "number", required: true, description: "Latitude" },
+            lon: { type: "number", required: true, description: "Longitude" },
+            date: { type: "string", required: false, description: "Date (YYYY-MM-DD)" },
+            dim: { type: "number", required: false, description: "Width/height in degrees (default 0.025)" },
+        },
+        async execute(input, ctx) {
+            const { lat, lon, date, dim } = input;
+            const qs = { lat, lon, dim: dim ?? 0.025 };
+            if (date)
+                qs.date = formatDate(date);
+            return apiRequest(key(ctx), "/planetary/earth/assets", qs);
+        },
+    });
+}

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

@@ -0,0 +1,151 @@
+const BASE = "https://api.netlify.com/api/v1";
+function getToken(ctx) {
+    return ctx.connection.config.accessToken;
+}
+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: `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(`Netlify API error ${res.status}: ${await res.text()}`);
+    const text = await res.text();
+    return text ? JSON.parse(text) : {};
+}
+async function paginate(token, endpoint, qs = {}) {
+    const all = [];
+    let page = 0;
+    const perPage = 100;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const url = new URL(`${BASE}${endpoint}`);
+        url.searchParams.set("page", String(page));
+        url.searchParams.set("per_page", String(perPage));
+        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(), {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        if (!res.ok)
+            throw new Error(`Netlify API error ${res.status}: ${await res.text()}`);
+        const items = (await res.json());
+        all.push(...items);
+        const link = res.headers.get("link") ?? "";
+        if (!link.includes("next"))
+            break;
+        page++;
+    }
+    return all;
+}
+export default function netlify(rl) {
+    rl.setName("netlify");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        accessToken: { type: "string", required: true, description: "Netlify personal access token", env: "NETLIFY_ACCESS_TOKEN" },
+    });
+    // ── Deploy ──────────────────────────────────────────
+    rl.registerAction("deploy.cancel", {
+        description: "Cancel a deployment",
+        inputSchema: {
+            deployId: { type: "string", required: true, description: "Deploy ID" },
+        },
+        async execute(input, ctx) {
+            const { deployId } = input;
+            return apiRequest(getToken(ctx), "POST", `/deploys/${deployId}/cancel`);
+        },
+    });
+    rl.registerAction("deploy.create", {
+        description: "Create a new deployment for a site",
+        inputSchema: {
+            siteId: { type: "string", required: true, description: "Site ID" },
+            branch: { type: "string", required: false, description: "Branch to deploy" },
+            title: { type: "string", required: false, description: "Deploy title" },
+        },
+        async execute(input, ctx) {
+            const { siteId, branch, title } = input;
+            const body = {};
+            const qs = {};
+            if (branch)
+                body.branch = branch;
+            if (title)
+                qs.title = title;
+            return apiRequest(getToken(ctx), "POST", `/sites/${siteId}/deploys`, body, qs);
+        },
+    });
+    rl.registerAction("deploy.get", {
+        description: "Get a deployment",
+        inputSchema: {
+            siteId: { type: "string", required: true, description: "Site ID" },
+            deployId: { type: "string", required: true, description: "Deploy ID" },
+        },
+        async execute(input, ctx) {
+            const { siteId, deployId } = input;
+            return apiRequest(getToken(ctx), "GET", `/sites/${siteId}/deploys/${deployId}`);
+        },
+    });
+    rl.registerAction("deploy.list", {
+        description: "List deployments for a site",
+        inputSchema: {
+            siteId: { type: "string", required: true, description: "Site ID" },
+            limit: { type: "number", required: false, description: "Max results (default all)" },
+        },
+        async execute(input, ctx) {
+            const { siteId, limit } = input;
+            const token = getToken(ctx);
+            if (limit) {
+                return apiRequest(token, "GET", `/sites/${siteId}/deploys`, undefined, { per_page: limit });
+            }
+            return paginate(token, `/sites/${siteId}/deploys`);
+        },
+    });
+    // ── Site ────────────────────────────────────────────
+    rl.registerAction("site.delete", {
+        description: "Delete a site",
+        inputSchema: {
+            siteId: { type: "string", required: true, description: "Site ID" },
+        },
+        async execute(input, ctx) {
+            const { siteId } = input;
+            return apiRequest(getToken(ctx), "DELETE", `/sites/${siteId}`);
+        },
+    });
+    rl.registerAction("site.get", {
+        description: "Get a site",
+        inputSchema: {
+            siteId: { type: "string", required: true, description: "Site ID" },
+        },
+        async execute(input, ctx) {
+            const { siteId } = input;
+            return apiRequest(getToken(ctx), "GET", `/sites/${siteId}`);
+        },
+    });
+    rl.registerAction("site.list", {
+        description: "List all sites",
+        inputSchema: {
+            limit: { type: "number", required: false, description: "Max results (default all)" },
+        },
+        async execute(input, ctx) {
+            const token = getToken(ctx);
+            const limit = input?.limit;
+            if (limit) {
+                return apiRequest(token, "GET", "/sites", undefined, { filter: "all", per_page: limit });
+            }
+            return paginate(token, "/sites", { filter: "all" });
+        },
+    });
+}