runline 0.1.0

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

@@ -0,0 +1,316 @@
+const BASE_URL = "https://api.getgo.com/G2W/rest/v2";
+async function apiRequest(accessToken, method, endpoint, body, qs) {
+    const url = new URL(`${BASE_URL}/${endpoint}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const opts = {
+        method,
+        headers: { Authorization: `Bearer ${accessToken}`, "Content-Type": "application/json", Accept: "application/json" },
+    };
+    if (body !== undefined && method !== "GET" && method !== "DELETE") {
+        opts.body = JSON.stringify(body);
+    }
+    const res = await fetch(url.toString(), opts);
+    if (!res.ok)
+        throw new Error(`GoToWebinar API error ${res.status}: ${await res.text()}`);
+    if (res.status === 204)
+        return { success: true };
+    const ct = res.headers.get("content-type") ?? "";
+    if (ct.includes("json"))
+        return res.json();
+    return { success: true };
+}
+function getConn(ctx) {
+    return {
+        accessToken: ctx.connection.config.accessToken,
+        organizerKey: ctx.connection.config.organizerKey,
+    };
+}
+export default function gotowebinar(rl) {
+    rl.setName("gotowebinar");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        accessToken: { type: "string", required: true, description: "GoTo OAuth2 access token", env: "GOTO_ACCESS_TOKEN" },
+        organizerKey: { type: "string", required: true, description: "Organizer key", env: "GOTO_ORGANIZER_KEY" },
+    });
+    // ── Webinar ─────────────────────────────────────────
+    rl.registerAction("webinar.create", {
+        description: "Create a webinar",
+        inputSchema: {
+            subject: { type: "string", required: true, description: "Webinar subject" },
+            times: { type: "array", required: true, description: "Array of {startTime, endTime} (ISO 8601)" },
+            description: { type: "string", required: false, description: "Description" },
+            timeZone: { type: "string", required: false, description: "Time zone" },
+            type: { type: "string", required: false, description: "single_session, series, sequence" },
+            isPasswordProtected: { type: "boolean", required: false, description: "Require password" },
+        },
+        async execute(input, ctx) {
+            const { subject, times, description: desc, timeZone, type, isPasswordProtected } = input;
+            const { accessToken, organizerKey } = getConn(ctx);
+            const body = { subject, times };
+            if (desc)
+                body.description = desc;
+            if (timeZone)
+                body.timeZone = timeZone;
+            if (type)
+                body.type = type;
+            if (isPasswordProtected !== undefined)
+                body.isPasswordProtected = isPasswordProtected;
+            return apiRequest(accessToken, "POST", `organizers/${organizerKey}/webinars`, body);
+        },
+    });
+    rl.registerAction("webinar.get", {
+        description: "Get a webinar",
+        inputSchema: { webinarKey: { type: "string", required: true, description: "Webinar key" } },
+        async execute(input, ctx) {
+            const { accessToken, organizerKey } = getConn(ctx);
+            return apiRequest(accessToken, "GET", `organizers/${organizerKey}/webinars/${input.webinarKey}`);
+        },
+    });
+    rl.registerAction("webinar.list", {
+        description: "List webinars",
+        inputSchema: { limit: { type: "number", required: false, description: "Max results" } },
+        async execute(input, ctx) {
+            const { accessToken, organizerKey } = getConn(ctx);
+            const data = (await apiRequest(accessToken, "GET", `organizers/${organizerKey}/webinars`));
+            const list = data._embedded?.webinars ?? data;
+            if (input?.limit && Array.isArray(list))
+                return list.slice(0, input.limit);
+            return list;
+        },
+    });
+    rl.registerAction("webinar.update", {
+        description: "Update a webinar",
+        inputSchema: {
+            webinarKey: { type: "string", required: true, description: "Webinar key" },
+            subject: { type: "string", required: false, description: "New subject" },
+            description: { type: "string", required: false, description: "New description" },
+            times: { type: "array", required: false, description: "New times" },
+            timeZone: { type: "string", required: false, description: "New time zone" },
+        },
+        async execute(input, ctx) {
+            const { webinarKey, subject, description: desc, times, timeZone } = input;
+            const { accessToken, organizerKey } = getConn(ctx);
+            const body = {};
+            if (subject)
+                body.subject = subject;
+            if (desc)
+                body.description = desc;
+            if (times)
+                body.times = times;
+            if (timeZone)
+                body.timeZone = timeZone;
+            return apiRequest(accessToken, "PUT", `organizers/${organizerKey}/webinars/${webinarKey}`, body);
+        },
+    });
+    rl.registerAction("webinar.delete", {
+        description: "Delete a webinar",
+        inputSchema: {
+            webinarKey: { type: "string", required: true, description: "Webinar key" },
+            sendCancellationEmails: { type: "boolean", required: false, description: "Send cancellation emails" },
+        },
+        async execute(input, ctx) {
+            const { webinarKey, sendCancellationEmails } = input;
+            const { accessToken, organizerKey } = getConn(ctx);
+            const qs = {};
+            if (sendCancellationEmails !== undefined)
+                qs.sendCancellationEmails = sendCancellationEmails;
+            await apiRequest(accessToken, "DELETE", `organizers/${organizerKey}/webinars/${webinarKey}`, undefined, qs);
+            return { success: true };
+        },
+    });
+    // ── Registrant ──────────────────────────────────────
+    rl.registerAction("registrant.create", {
+        description: "Register a person for a webinar",
+        inputSchema: {
+            webinarKey: { type: "string", required: true, description: "Webinar key" },
+            firstName: { type: "string", required: true, description: "First name" },
+            lastName: { type: "string", required: true, description: "Last name" },
+            email: { type: "string", required: true, description: "Email" },
+        },
+        async execute(input, ctx) {
+            const { webinarKey, firstName, lastName, email } = input;
+            const { accessToken, organizerKey } = getConn(ctx);
+            return apiRequest(accessToken, "POST", `organizers/${organizerKey}/webinars/${webinarKey}/registrants`, { firstName, lastName, email });
+        },
+    });
+    rl.registerAction("registrant.get", {
+        description: "Get a registrant",
+        inputSchema: {
+            webinarKey: { type: "string", required: true, description: "Webinar key" },
+            registrantKey: { type: "string", required: true, description: "Registrant key" },
+        },
+        async execute(input, ctx) {
+            const { webinarKey, registrantKey } = input;
+            const { accessToken, organizerKey } = getConn(ctx);
+            return apiRequest(accessToken, "GET", `organizers/${organizerKey}/webinars/${webinarKey}/registrants/${registrantKey}`);
+        },
+    });
+    rl.registerAction("registrant.list", {
+        description: "List registrants for a webinar",
+        inputSchema: { webinarKey: { type: "string", required: true, description: "Webinar key" } },
+        async execute(input, ctx) {
+            const { accessToken, organizerKey } = getConn(ctx);
+            return apiRequest(accessToken, "GET", `organizers/${organizerKey}/webinars/${input.webinarKey}/registrants`);
+        },
+    });
+    rl.registerAction("registrant.delete", {
+        description: "Delete a registrant",
+        inputSchema: {
+            webinarKey: { type: "string", required: true, description: "Webinar key" },
+            registrantKey: { type: "string", required: true, description: "Registrant key" },
+        },
+        async execute(input, ctx) {
+            const { webinarKey, registrantKey } = input;
+            const { accessToken, organizerKey } = getConn(ctx);
+            await apiRequest(accessToken, "DELETE", `organizers/${organizerKey}/webinars/${webinarKey}/registrants/${registrantKey}`);
+            return { success: true };
+        },
+    });
+    // ── Session ─────────────────────────────────────────
+    rl.registerAction("session.get", {
+        description: "Get a session",
+        inputSchema: {
+            webinarKey: { type: "string", required: true, description: "Webinar key" },
+            sessionKey: { type: "string", required: true, description: "Session key" },
+        },
+        async execute(input, ctx) {
+            const { webinarKey, sessionKey } = input;
+            const { accessToken, organizerKey } = getConn(ctx);
+            return apiRequest(accessToken, "GET", `organizers/${organizerKey}/webinars/${webinarKey}/sessions/${sessionKey}`);
+        },
+    });
+    rl.registerAction("session.list", {
+        description: "List sessions for a webinar",
+        inputSchema: { webinarKey: { type: "string", required: true, description: "Webinar key" } },
+        async execute(input, ctx) {
+            const { accessToken, organizerKey } = getConn(ctx);
+            return apiRequest(accessToken, "GET", `organizers/${organizerKey}/webinars/${input.webinarKey}/sessions`);
+        },
+    });
+    rl.registerAction("session.getPerformance", {
+        description: "Get session performance details",
+        inputSchema: {
+            webinarKey: { type: "string", required: true, description: "Webinar key" },
+            sessionKey: { type: "string", required: true, description: "Session key" },
+        },
+        async execute(input, ctx) {
+            const { webinarKey, sessionKey } = input;
+            const { accessToken, organizerKey } = getConn(ctx);
+            return apiRequest(accessToken, "GET", `organizers/${organizerKey}/webinars/${webinarKey}/sessions/${sessionKey}/performance`);
+        },
+    });
+    // ── Attendee ────────────────────────────────────────
+    rl.registerAction("attendee.get", {
+        description: "Get an attendee",
+        inputSchema: {
+            webinarKey: { type: "string", required: true, description: "Webinar key" },
+            sessionKey: { type: "string", required: true, description: "Session key" },
+            registrantKey: { type: "string", required: true, description: "Registrant key" },
+        },
+        async execute(input, ctx) {
+            const { webinarKey, sessionKey, registrantKey } = input;
+            const { accessToken, organizerKey } = getConn(ctx);
+            return apiRequest(accessToken, "GET", `organizers/${organizerKey}/webinars/${webinarKey}/sessions/${sessionKey}/attendees/${registrantKey}`);
+        },
+    });
+    rl.registerAction("attendee.list", {
+        description: "List attendees for a session",
+        inputSchema: {
+            webinarKey: { type: "string", required: true, description: "Webinar key" },
+            sessionKey: { type: "string", required: true, description: "Session key" },
+        },
+        async execute(input, ctx) {
+            const { webinarKey, sessionKey } = input;
+            const { accessToken, organizerKey } = getConn(ctx);
+            return apiRequest(accessToken, "GET", `organizers/${organizerKey}/webinars/${webinarKey}/sessions/${sessionKey}/attendees`);
+        },
+    });
+    // ── Coorganizer ─────────────────────────────────────
+    rl.registerAction("coorganizer.create", {
+        description: "Add a co-organizer to a webinar",
+        inputSchema: {
+            webinarKey: { type: "string", required: true, description: "Webinar key" },
+            external: { type: "boolean", required: true, description: "true for external, false for internal" },
+            organizerKey: { type: "string", required: false, description: "Organizer key (internal)" },
+            givenName: { type: "string", required: false, description: "First name (external)" },
+            email: { type: "string", required: false, description: "Email (external)" },
+        },
+        async execute(input, ctx) {
+            const { webinarKey, external, organizerKey: coorgKey, givenName, email } = input;
+            const { accessToken, organizerKey } = getConn(ctx);
+            const body = { external };
+            if (coorgKey)
+                body.organizerKey = coorgKey;
+            if (givenName)
+                body.givenName = givenName;
+            if (email)
+                body.email = email;
+            return apiRequest(accessToken, "POST", `organizers/${organizerKey}/webinars/${webinarKey}/coorganizers`, [body]);
+        },
+    });
+    rl.registerAction("coorganizer.list", {
+        description: "List co-organizers",
+        inputSchema: { webinarKey: { type: "string", required: true, description: "Webinar key" } },
+        async execute(input, ctx) {
+            const { accessToken, organizerKey } = getConn(ctx);
+            return apiRequest(accessToken, "GET", `organizers/${organizerKey}/webinars/${input.webinarKey}/coorganizers`);
+        },
+    });
+    rl.registerAction("coorganizer.delete", {
+        description: "Remove a co-organizer",
+        inputSchema: {
+            webinarKey: { type: "string", required: true, description: "Webinar key" },
+            coorganizerKey: { type: "string", required: true, description: "Co-organizer key" },
+            external: { type: "boolean", required: false, description: "Whether external" },
+        },
+        async execute(input, ctx) {
+            const { webinarKey, coorganizerKey, external } = input;
+            const { accessToken, organizerKey } = getConn(ctx);
+            const qs = {};
+            if (external !== undefined)
+                qs.external = external;
+            await apiRequest(accessToken, "DELETE", `organizers/${organizerKey}/webinars/${webinarKey}/coorganizers/${coorganizerKey}`, undefined, qs);
+            return { success: true };
+        },
+    });
+    // ── Panelist ────────────────────────────────────────
+    rl.registerAction("panelist.create", {
+        description: "Add a panelist to a webinar",
+        inputSchema: {
+            webinarKey: { type: "string", required: true, description: "Webinar key" },
+            name: { type: "string", required: true, description: "Panelist name" },
+            email: { type: "string", required: true, description: "Panelist email" },
+        },
+        async execute(input, ctx) {
+            const { webinarKey, name, email } = input;
+            const { accessToken, organizerKey } = getConn(ctx);
+            return apiRequest(accessToken, "POST", `organizers/${organizerKey}/webinars/${webinarKey}/panelists`, [{ name, email }]);
+        },
+    });
+    rl.registerAction("panelist.list", {
+        description: "List panelists",
+        inputSchema: { webinarKey: { type: "string", required: true, description: "Webinar key" } },
+        async execute(input, ctx) {
+            const { accessToken, organizerKey } = getConn(ctx);
+            return apiRequest(accessToken, "GET", `organizers/${organizerKey}/webinars/${input.webinarKey}/panelists`);
+        },
+    });
+    rl.registerAction("panelist.delete", {
+        description: "Remove a panelist",
+        inputSchema: {
+            webinarKey: { type: "string", required: true, description: "Webinar key" },
+            panelistKey: { type: "string", required: true, description: "Panelist key" },
+        },
+        async execute(input, ctx) {
+            const { webinarKey, panelistKey } = input;
+            const { accessToken, organizerKey } = getConn(ctx);
+            await apiRequest(accessToken, "DELETE", `organizers/${organizerKey}/webinars/${webinarKey}/panelists/${panelistKey}`);
+            return { success: true };
+        },
+    });
+}

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

@@ -0,0 +1,250 @@
+async function apiRequest(baseUrl, apiKey, method, endpoint, body, qs) {
+    const url = new URL(`${baseUrl}/api${endpoint}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const opts = {
+        method,
+        headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+    };
+    if (body && Object.keys(body).length > 0 && method !== "GET" && method !== "DELETE") {
+        opts.body = JSON.stringify(body);
+    }
+    const res = await fetch(url.toString(), opts);
+    if (!res.ok)
+        throw new Error(`Grafana API error ${res.status}: ${await res.text()}`);
+    if (res.status === 204)
+        return { success: true };
+    return res.json();
+}
+function getConn(ctx) {
+    return {
+        baseUrl: ctx.connection.config.baseUrl.replace(/\/$/, ""),
+        apiKey: ctx.connection.config.apiKey,
+    };
+}
+function gf(ctx, method, endpoint, body, qs) {
+    const { baseUrl, apiKey } = getConn(ctx);
+    return apiRequest(baseUrl, apiKey, method, endpoint, body, qs);
+}
+export default function grafana(rl) {
+    rl.setName("grafana");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        baseUrl: { type: "string", required: true, description: "Grafana base URL (e.g. https://grafana.example.com)", env: "GRAFANA_URL" },
+        apiKey: { type: "string", required: true, description: "Grafana API key or service account token", env: "GRAFANA_API_KEY" },
+    });
+    // ── Dashboard ───────────────────────────────────────
+    rl.registerAction("dashboard.create", {
+        description: "Create or save a dashboard",
+        inputSchema: {
+            dashboard: { type: "object", required: true, description: "Dashboard JSON model" },
+            folderId: { type: "number", required: false, description: "Folder ID" },
+            overwrite: { type: "boolean", required: false, description: "Overwrite existing" },
+            message: { type: "string", required: false, description: "Save message" },
+        },
+        async execute(input, ctx) {
+            const { dashboard, folderId, overwrite, message } = input;
+            const body = { dashboard };
+            if (folderId !== undefined)
+                body.folderId = folderId;
+            if (overwrite !== undefined)
+                body.overwrite = overwrite;
+            if (message)
+                body.message = message;
+            return gf(ctx, "POST", "/dashboards/db", body);
+        },
+    });
+    rl.registerAction("dashboard.get", {
+        description: "Get a dashboard by UID",
+        inputSchema: { uid: { type: "string", required: true, description: "Dashboard UID" } },
+        async execute(input, ctx) {
+            return gf(ctx, "GET", `/dashboards/uid/${input.uid}`);
+        },
+    });
+    rl.registerAction("dashboard.list", {
+        description: "Search dashboards",
+        inputSchema: {
+            query: { type: "string", required: false, description: "Search query" },
+            tag: { type: "string", required: false, description: "Filter by tag" },
+            type: { type: "string", required: false, description: "dash-db or dash-folder" },
+            folderId: { type: "number", required: false, description: "Filter by folder ID" },
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { query, tag, type, folderId, limit } = (input ?? {});
+            const qs = {};
+            if (query)
+                qs.query = query;
+            if (tag)
+                qs.tag = tag;
+            if (type)
+                qs.type = type;
+            if (folderId !== undefined)
+                qs.folderIds = folderId;
+            if (limit)
+                qs.limit = limit;
+            return gf(ctx, "GET", "/search", undefined, qs);
+        },
+    });
+    rl.registerAction("dashboard.delete", {
+        description: "Delete a dashboard by UID",
+        inputSchema: { uid: { type: "string", required: true, description: "Dashboard UID" } },
+        async execute(input, ctx) {
+            return gf(ctx, "DELETE", `/dashboards/uid/${input.uid}`);
+        },
+    });
+    rl.registerAction("dashboard.update", {
+        description: "Update an existing dashboard",
+        inputSchema: {
+            uid: { type: "string", required: true, description: "Dashboard UID to update" },
+            dashboard: { type: "object", required: true, description: "Updated dashboard JSON model" },
+            folderId: { type: "number", required: false, description: "Folder ID" },
+            message: { type: "string", required: false, description: "Save message" },
+        },
+        async execute(input, ctx) {
+            const { uid, dashboard, folderId, message } = input;
+            const body = { dashboard: { ...dashboard, uid }, overwrite: true };
+            if (folderId !== undefined)
+                body.folderId = folderId;
+            if (message)
+                body.message = message;
+            return gf(ctx, "POST", "/dashboards/db", body);
+        },
+    });
+    // ── Team ────────────────────────────────────────────
+    rl.registerAction("team.create", {
+        description: "Create a team",
+        inputSchema: {
+            name: { type: "string", required: true, description: "Team name" },
+            email: { type: "string", required: false, description: "Team email" },
+        },
+        async execute(input, ctx) {
+            const { name, email } = input;
+            const body = { name };
+            if (email)
+                body.email = email;
+            return gf(ctx, "POST", "/teams", body);
+        },
+    });
+    rl.registerAction("team.get", {
+        description: "Get a team by ID",
+        inputSchema: { teamId: { type: "number", required: true, description: "Team ID" } },
+        async execute(input, ctx) {
+            return gf(ctx, "GET", `/teams/${input.teamId}`);
+        },
+    });
+    rl.registerAction("team.list", {
+        description: "Search teams",
+        inputSchema: {
+            query: { type: "string", required: false, description: "Search by name" },
+            limit: { type: "number", required: false, description: "Max results" },
+            page: { type: "number", required: false, description: "Page number" },
+        },
+        async execute(input, ctx) {
+            const { query, limit, page } = (input ?? {});
+            const qs = {};
+            if (query)
+                qs.query = query;
+            if (limit)
+                qs.perpage = limit;
+            if (page)
+                qs.page = page;
+            const data = (await gf(ctx, "GET", "/teams/search", undefined, qs));
+            return data.teams;
+        },
+    });
+    rl.registerAction("team.update", {
+        description: "Update a team",
+        inputSchema: {
+            teamId: { type: "number", required: true, description: "Team ID" },
+            name: { type: "string", required: false, description: "New name" },
+            email: { type: "string", required: false, description: "New email" },
+        },
+        async execute(input, ctx) {
+            const { teamId, name, email } = input;
+            const body = {};
+            if (name)
+                body.name = name;
+            if (email)
+                body.email = email;
+            return gf(ctx, "PUT", `/teams/${teamId}`, body);
+        },
+    });
+    rl.registerAction("team.delete", {
+        description: "Delete a team",
+        inputSchema: { teamId: { type: "number", required: true, description: "Team ID" } },
+        async execute(input, ctx) {
+            return gf(ctx, "DELETE", `/teams/${input.teamId}`);
+        },
+    });
+    // ── Team Member ─────────────────────────────────────
+    rl.registerAction("teamMember.add", {
+        description: "Add a user to a team",
+        inputSchema: {
+            teamId: { type: "number", required: true, description: "Team ID" },
+            userId: { type: "number", required: true, description: "User ID to add" },
+        },
+        async execute(input, ctx) {
+            const { teamId, userId } = input;
+            return gf(ctx, "POST", `/teams/${teamId}/members`, { userId });
+        },
+    });
+    rl.registerAction("teamMember.remove", {
+        description: "Remove a user from a team",
+        inputSchema: {
+            teamId: { type: "number", required: true, description: "Team ID" },
+            userId: { type: "number", required: true, description: "User ID to remove" },
+        },
+        async execute(input, ctx) {
+            const { teamId, userId } = input;
+            return gf(ctx, "DELETE", `/teams/${teamId}/members/${userId}`);
+        },
+    });
+    rl.registerAction("teamMember.list", {
+        description: "List members of a team",
+        inputSchema: { teamId: { type: "number", required: true, description: "Team ID" } },
+        async execute(input, ctx) {
+            return gf(ctx, "GET", `/teams/${input.teamId}/members`);
+        },
+    });
+    // ── User (Org) ──────────────────────────────────────
+    rl.registerAction("user.create", {
+        description: "Add a user to the current organization",
+        inputSchema: {
+            loginOrEmail: { type: "string", required: true, description: "Login name or email" },
+            role: { type: "string", required: true, description: "Viewer, Editor, or Admin" },
+        },
+        async execute(input, ctx) {
+            const { loginOrEmail, role } = input;
+            return gf(ctx, "POST", "/org/users", { loginOrEmail, role });
+        },
+    });
+    rl.registerAction("user.list", {
+        description: "List users in the current organization",
+        async execute(_input, ctx) {
+            return gf(ctx, "GET", "/org/users");
+        },
+    });
+    rl.registerAction("user.update", {
+        description: "Update a user's role in the organization",
+        inputSchema: {
+            userId: { type: "number", required: true, description: "User ID" },
+            role: { type: "string", required: true, description: "Viewer, Editor, or Admin" },
+        },
+        async execute(input, ctx) {
+            const { userId, role } = input;
+            return gf(ctx, "PATCH", `/org/users/${userId}`, { role });
+        },
+    });
+    rl.registerAction("user.delete", {
+        description: "Remove a user from the organization",
+        inputSchema: { userId: { type: "number", required: true, description: "User ID" } },
+        async execute(input, ctx) {
+            return gf(ctx, "DELETE", `/org/users/${input.userId}`);
+        },
+    });
+}

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

@@ -0,0 +1,78 @@
+export default function graphql(rl) {
+    rl.setName("graphql");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        endpoint: { type: "string", required: true, description: "GraphQL endpoint URL", env: "GRAPHQL_ENDPOINT" },
+        headerAuth: { type: "string", required: false, description: "Authorization header value (e.g. 'Bearer xxx')", env: "GRAPHQL_AUTH_HEADER" },
+        headers: { type: "object", required: false, description: "Additional headers as key-value pairs" },
+    });
+    rl.registerAction("query", {
+        description: "Execute a GraphQL query",
+        inputSchema: {
+            query: { type: "string", required: true, description: "GraphQL query or mutation string" },
+            variables: { type: "object", required: false, description: "Query variables" },
+            operationName: { type: "string", required: false, description: "Operation name (if query contains multiple)" },
+        },
+        async execute(input, ctx) {
+            const { query, variables, operationName } = input;
+            const cfg = ctx.connection.config;
+            const endpoint = cfg.endpoint;
+            const hdrs = { "Content-Type": "application/json" };
+            if (cfg.headerAuth)
+                hdrs.Authorization = cfg.headerAuth;
+            if (cfg.headers) {
+                for (const [k, v] of Object.entries(cfg.headers)) {
+                    hdrs[k] = v;
+                }
+            }
+            const body = { query };
+            if (variables)
+                body.variables = variables;
+            if (operationName)
+                body.operationName = operationName;
+            const res = await fetch(endpoint, {
+                method: "POST",
+                headers: hdrs,
+                body: JSON.stringify(body),
+            });
+            if (!res.ok)
+                throw new Error(`GraphQL error ${res.status}: ${await res.text()}`);
+            const data = (await res.json());
+            if (data.errors)
+                throw new Error(`GraphQL errors: ${JSON.stringify(data.errors)}`);
+            return data.data;
+        },
+    });
+    rl.registerAction("introspect", {
+        description: "Run an introspection query to get the schema",
+        async execute(_input, ctx) {
+            const cfg = ctx.connection.config;
+            const endpoint = cfg.endpoint;
+            const hdrs = { "Content-Type": "application/json" };
+            if (cfg.headerAuth)
+                hdrs.Authorization = cfg.headerAuth;
+            if (cfg.headers) {
+                for (const [k, v] of Object.entries(cfg.headers)) {
+                    hdrs[k] = v;
+                }
+            }
+            const introspectionQuery = `{
+        __schema {
+          types { name kind description fields { name type { name kind ofType { name kind } } } }
+          queryType { name }
+          mutationType { name }
+          subscriptionType { name }
+        }
+      }`;
+            const res = await fetch(endpoint, {
+                method: "POST",
+                headers: hdrs,
+                body: JSON.stringify({ query: introspectionQuery }),
+            });
+            if (!res.ok)
+                throw new Error(`GraphQL error ${res.status}: ${await res.text()}`);
+            const data = (await res.json());
+            return data.data;
+        },
+    });
+}