runline 0.1.0

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

@@ -0,0 +1,156 @@
+const BASE_URL = "https://api.intercom.io";
+async function apiRequest(token, 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 ${token}`, "Content-Type": "application/json", Accept: "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(`Intercom API error ${res.status}: ${await res.text()}`);
+    if (res.status === 204)
+        return { success: true };
+    return res.json();
+}
+export default function intercom(rl) {
+    rl.setName("intercom");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({ accessToken: { type: "string", required: true, description: "Intercom access token", env: "INTERCOM_ACCESS_TOKEN" } });
+    const tok = (ctx) => ctx.connection.config.accessToken;
+    // ── Contact (unified leads + users in v2) ───────────
+    rl.registerAction("contact.create", {
+        description: "Create a contact (lead or user)",
+        inputSchema: {
+            role: { type: "string", required: true, description: "lead or user" },
+            email: { type: "string", required: false, description: "Email" },
+            name: { type: "string", required: false, description: "Full name" },
+            phone: { type: "string", required: false, description: "Phone" },
+            externalId: { type: "string", required: false, description: "External ID (for users)" },
+            customAttributes: { type: "object", required: false, description: "Custom attributes" },
+        },
+        async execute(input, ctx) {
+            const { role, email, name, phone, externalId, customAttributes } = input;
+            const body = { role };
+            if (email)
+                body.email = email;
+            if (name)
+                body.name = name;
+            if (phone)
+                body.phone = phone;
+            if (externalId)
+                body.external_id = externalId;
+            if (customAttributes)
+                body.custom_attributes = customAttributes;
+            return apiRequest(tok(ctx), "POST", "/contacts", body);
+        },
+    });
+    rl.registerAction("contact.get", {
+        description: "Get a contact by ID",
+        inputSchema: { contactId: { type: "string", required: true, description: "Contact ID" } },
+        async execute(input, ctx) { return apiRequest(tok(ctx), "GET", `/contacts/${input.contactId}`); },
+    });
+    rl.registerAction("contact.list", {
+        description: "List contacts",
+        inputSchema: { limit: { type: "number", required: false, description: "Max results" }, startingAfter: { type: "string", required: false, description: "Pagination cursor" } },
+        async execute(input, ctx) {
+            const { limit, startingAfter } = (input ?? {});
+            const qs = {};
+            if (limit)
+                qs.per_page = limit;
+            if (startingAfter)
+                qs.starting_after = startingAfter;
+            return apiRequest(tok(ctx), "GET", "/contacts", undefined, qs);
+        },
+    });
+    rl.registerAction("contact.update", {
+        description: "Update a contact",
+        inputSchema: {
+            contactId: { type: "string", required: true, description: "Contact ID" },
+            email: { type: "string", required: false, description: "Email" },
+            name: { type: "string", required: false, description: "Name" },
+            phone: { type: "string", required: false, description: "Phone" },
+            customAttributes: { type: "object", required: false, description: "Custom attributes" },
+        },
+        async execute(input, ctx) {
+            const { contactId, email, name, phone, customAttributes } = input;
+            const body = {};
+            if (email)
+                body.email = email;
+            if (name)
+                body.name = name;
+            if (phone)
+                body.phone = phone;
+            if (customAttributes)
+                body.custom_attributes = customAttributes;
+            return apiRequest(tok(ctx), "PUT", `/contacts/${contactId}`, body);
+        },
+    });
+    rl.registerAction("contact.delete", {
+        description: "Delete a contact",
+        inputSchema: { contactId: { type: "string", required: true, description: "Contact ID" } },
+        async execute(input, ctx) { return apiRequest(tok(ctx), "DELETE", `/contacts/${input.contactId}`); },
+    });
+    rl.registerAction("contact.search", {
+        description: "Search contacts",
+        inputSchema: {
+            query: { type: "object", required: true, description: "Search query object (Intercom search format)" },
+            limit: { type: "number", required: false, description: "Max results per page" },
+        },
+        async execute(input, ctx) {
+            const { query, limit } = input;
+            const body = { query };
+            if (limit)
+                body.pagination = { per_page: limit };
+            return apiRequest(tok(ctx), "POST", "/contacts/search", body);
+        },
+    });
+    // ── Company ─────────────────────────────────────────
+    rl.registerAction("company.create", {
+        description: "Create or update a company",
+        inputSchema: {
+            companyId: { type: "string", required: true, description: "Company ID (your identifier)" },
+            name: { type: "string", required: false, description: "Company name" },
+            plan: { type: "string", required: false, description: "Plan name" },
+            customAttributes: { type: "object", required: false, description: "Custom attributes" },
+        },
+        async execute(input, ctx) {
+            const { companyId, name, plan, customAttributes } = input;
+            const body = { company_id: companyId };
+            if (name)
+                body.name = name;
+            if (plan)
+                body.plan = plan;
+            if (customAttributes)
+                body.custom_attributes = customAttributes;
+            return apiRequest(tok(ctx), "POST", "/companies", body);
+        },
+    });
+    rl.registerAction("company.get", {
+        description: "Get a company",
+        inputSchema: { companyId: { type: "string", required: true, description: "Intercom company ID" } },
+        async execute(input, ctx) { return apiRequest(tok(ctx), "GET", `/companies/${input.companyId}`); },
+    });
+    rl.registerAction("company.list", {
+        description: "List companies",
+        inputSchema: { limit: { type: "number", required: false, description: "Max results" }, page: { type: "number", required: false, description: "Page" } },
+        async execute(input, ctx) {
+            const { limit, page } = (input ?? {});
+            const qs = {};
+            if (limit)
+                qs.per_page = limit;
+            if (page)
+                qs.page = page;
+            return apiRequest(tok(ctx), "GET", "/companies", undefined, qs);
+        },
+    });
+    rl.registerAction("company.listUsers", {
+        description: "List users of a company",
+        inputSchema: { companyId: { type: "string", required: true, description: "Company ID" } },
+        async execute(input, ctx) { return apiRequest(tok(ctx), "GET", `/companies/${input.companyId}/contacts`); },
+    });
+}

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

@@ -0,0 +1,139 @@
+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: { "Api-Key": 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(`Iterable API error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+export default function iterable(rl) {
+    rl.setName("iterable");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: { type: "string", required: true, description: "Iterable API key", env: "ITERABLE_API_KEY" },
+        region: { type: "string", required: false, description: "API base URL (default: https://api.iterable.com)", env: "ITERABLE_REGION", default: "https://api.iterable.com" },
+    });
+    const conn = (ctx) => ({
+        baseUrl: (ctx.connection.config.region ?? "https://api.iterable.com").replace(/\/$/, ""),
+        apiKey: ctx.connection.config.apiKey,
+    });
+    // ── Event ───────────────────────────────────────────
+    rl.registerAction("event.track", {
+        description: "Track events for users (bulk). Each event requires email or userId, plus eventName.",
+        inputSchema: {
+            events: {
+                type: "array", required: true,
+                description: "Array of event objects. Each needs: eventName (string, required), email or id (string, one required), dataFields (object, optional), createdAt (unix timestamp, optional)",
+            },
+        },
+        async execute(input, ctx) {
+            const { events } = input;
+            const { baseUrl, apiKey } = conn(ctx);
+            return apiRequest(baseUrl, apiKey, "POST", "/events/trackBulk", { events });
+        },
+    });
+    // ── User ────────────────────────────────────────────
+    rl.registerAction("user.upsert", {
+        description: "Create or update a user",
+        inputSchema: {
+            identifier: { type: "string", required: true, description: "'email' or 'userId'" },
+            value: { type: "string", required: true, description: "The email address or userId value" },
+            preferUserId: { type: "boolean", required: false, description: "When identifier is userId, prefer userId for lookups (default false)" },
+            dataFields: { type: "object", required: false, description: "User data fields as key-value pairs" },
+        },
+        async execute(input, ctx) {
+            const { identifier, value, preferUserId, dataFields } = input;
+            const { baseUrl, apiKey } = conn(ctx);
+            const body = {};
+            if (identifier === "email") {
+                body.email = value;
+            }
+            else {
+                body.userId = value;
+                if (preferUserId !== undefined)
+                    body.preferUserId = preferUserId;
+            }
+            if (dataFields)
+                body.dataFields = dataFields;
+            return apiRequest(baseUrl, apiKey, "POST", "/users/update", body);
+        },
+    });
+    rl.registerAction("user.get", {
+        description: "Get a user by email or userId",
+        inputSchema: {
+            by: { type: "string", required: true, description: "'email' or 'userId'" },
+            value: { type: "string", required: true, description: "The email address or userId" },
+        },
+        async execute(input, ctx) {
+            const { by, value } = input;
+            const { baseUrl, apiKey } = conn(ctx);
+            if (by === "email") {
+                const data = await apiRequest(baseUrl, apiKey, "GET", "/users/getByEmail", undefined, { email: value });
+                return data.user ?? data;
+            }
+            return apiRequest(baseUrl, apiKey, "GET", `/users/byUserId/${encodeURIComponent(value)}`);
+        },
+    });
+    rl.registerAction("user.delete", {
+        description: "Delete a user by email or userId",
+        inputSchema: {
+            by: { type: "string", required: true, description: "'email' or 'userId'" },
+            value: { type: "string", required: true, description: "The email address or userId" },
+        },
+        async execute(input, ctx) {
+            const { by, value } = input;
+            const { baseUrl, apiKey } = conn(ctx);
+            const endpoint = by === "email"
+                ? `/users/${encodeURIComponent(value)}`
+                : `/users/byUserId/${encodeURIComponent(value)}`;
+            return apiRequest(baseUrl, apiKey, "DELETE", endpoint);
+        },
+    });
+    // ── User List ───────────────────────────────────────
+    rl.registerAction("userList.add", {
+        description: "Subscribe users to a list",
+        inputSchema: {
+            listId: { type: "number", required: true, description: "List ID" },
+            identifier: { type: "string", required: true, description: "'email' or 'userId'" },
+            values: { type: "array", required: true, description: "Array of email addresses or userIds to subscribe" },
+        },
+        async execute(input, ctx) {
+            const { listId, identifier, values } = input;
+            const { baseUrl, apiKey } = conn(ctx);
+            const subscribers = values.map((v) => identifier === "email" ? { email: v } : { userId: v });
+            return apiRequest(baseUrl, apiKey, "POST", "/lists/subscribe", { listId, subscribers });
+        },
+    });
+    rl.registerAction("userList.remove", {
+        description: "Unsubscribe users from a list",
+        inputSchema: {
+            listId: { type: "number", required: true, description: "List ID" },
+            identifier: { type: "string", required: true, description: "'email' or 'userId'" },
+            values: { type: "array", required: true, description: "Array of email addresses or userIds to unsubscribe" },
+            campaignId: { type: "number", required: false, description: "Campaign ID for attribution" },
+            channelUnsubscribe: { type: "boolean", required: false, description: "Unsubscribe from channel" },
+        },
+        async execute(input, ctx) {
+            const { listId, identifier, values, campaignId, channelUnsubscribe } = input;
+            const { baseUrl, apiKey } = conn(ctx);
+            const subscribers = values.map((v) => identifier === "email" ? { email: v } : { userId: v });
+            const body = { listId, subscribers };
+            if (campaignId !== undefined)
+                body.campaignId = campaignId;
+            if (channelUnsubscribe !== undefined)
+                body.channelUnsubscribe = channelUnsubscribe;
+            return apiRequest(baseUrl, apiKey, "POST", "/lists/unsubscribe", body);
+        },
+    });
+}

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

@@ -0,0 +1,132 @@
+async function apiRequest(baseUrl, username, apiToken, method, endpoint, body, contentType, qs) {
+    const url = new URL(`${baseUrl}${endpoint}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const headers = { Authorization: `Basic ${btoa(`${username}:${apiToken}`)}` };
+    if (contentType)
+        headers["Content-Type"] = contentType;
+    const opts = { method, headers };
+    if (body && method !== "GET")
+        opts.body = typeof body === "string" ? body : JSON.stringify(body);
+    const res = await fetch(url.toString(), opts);
+    if (!res.ok)
+        throw new Error(`Jenkins error ${res.status}: ${await res.text()}`);
+    const ct = res.headers.get("content-type") ?? "";
+    if (ct.includes("json"))
+        return res.json();
+    return { success: true };
+}
+function getConn(ctx) {
+    return {
+        baseUrl: ctx.connection.config.baseUrl.replace(/\/$/, ""),
+        username: ctx.connection.config.username,
+        apiToken: ctx.connection.config.apiToken,
+    };
+}
+function jk(ctx, method, endpoint, body, ct, qs) {
+    const { baseUrl, username, apiToken } = getConn(ctx);
+    return apiRequest(baseUrl, username, apiToken, method, endpoint, body, ct, qs);
+}
+export default function jenkins(rl) {
+    rl.setName("jenkins");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        baseUrl: { type: "string", required: true, description: "Jenkins URL (e.g. https://jenkins.example.com)", env: "JENKINS_URL" },
+        username: { type: "string", required: true, description: "Jenkins username", env: "JENKINS_USER" },
+        apiToken: { type: "string", required: true, description: "Jenkins API token", env: "JENKINS_TOKEN" },
+    });
+    // ── Job ─────────────────────────────────────────────
+    rl.registerAction("job.trigger", {
+        description: "Trigger a job build",
+        inputSchema: {
+            jobName: { type: "string", required: true, description: "Job name (URL-encoded if nested)" },
+            parameters: { type: "object", required: false, description: "Build parameters as key-value pairs" },
+        },
+        async execute(input, ctx) {
+            const { jobName, parameters } = input;
+            if (parameters && Object.keys(parameters).length > 0) {
+                const qs = parameters;
+                await jk(ctx, "POST", `/job/${jobName}/buildWithParameters`, undefined, undefined, qs);
+            }
+            else {
+                await jk(ctx, "POST", `/job/${jobName}/build`);
+            }
+            return { success: true };
+        },
+    });
+    rl.registerAction("job.getParameters", {
+        description: "Get build parameters for a job",
+        inputSchema: { jobName: { type: "string", required: true, description: "Job name" } },
+        async execute(input, ctx) {
+            const data = (await jk(ctx, "GET", `/job/${input.jobName}/api/json`, undefined, undefined, { tree: "actions[parameterDefinitions[*]]" }));
+            return data.actions;
+        },
+    });
+    rl.registerAction("job.copy", {
+        description: "Copy/create a job from an existing one",
+        inputSchema: {
+            fromJob: { type: "string", required: true, description: "Source job name" },
+            newName: { type: "string", required: true, description: "New job name" },
+        },
+        async execute(input, ctx) {
+            const { fromJob, newName } = input;
+            await jk(ctx, "POST", "/createItem", undefined, undefined, { name: newName, mode: "copy", from: fromJob });
+            return { success: true };
+        },
+    });
+    rl.registerAction("job.create", {
+        description: "Create a job from XML config",
+        inputSchema: {
+            name: { type: "string", required: true, description: "Job name" },
+            xml: { type: "string", required: true, description: "Jenkins job config XML" },
+        },
+        async execute(input, ctx) {
+            const { name, xml } = input;
+            await jk(ctx, "POST", "/createItem", xml, "application/xml", { name });
+            return { success: true };
+        },
+    });
+    // ── Build ───────────────────────────────────────────
+    rl.registerAction("build.list", {
+        description: "List builds for a job",
+        inputSchema: {
+            jobName: { type: "string", required: true, description: "Job name" },
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { jobName, limit } = input;
+            const tree = limit ? `builds[*]{0,${limit}}` : "builds[*]";
+            const data = (await jk(ctx, "GET", `/job/${jobName}/api/json`, undefined, undefined, { tree }));
+            return data.builds;
+        },
+    });
+    // ── Instance ────────────────────────────────────────
+    rl.registerAction("instance.quietDown", {
+        description: "Put Jenkins into quiet mode (no new builds)",
+        async execute(_input, ctx) { await jk(ctx, "POST", "/quietDown"); return { success: true }; },
+    });
+    rl.registerAction("instance.cancelQuietDown", {
+        description: "Cancel quiet mode",
+        async execute(_input, ctx) { await jk(ctx, "POST", "/cancelQuietDown"); return { success: true }; },
+    });
+    rl.registerAction("instance.restart", {
+        description: "Restart Jenkins immediately",
+        async execute(_input, ctx) { await jk(ctx, "POST", "/restart"); return { success: true }; },
+    });
+    rl.registerAction("instance.safeRestart", {
+        description: "Restart Jenkins after running builds finish",
+        async execute(_input, ctx) { await jk(ctx, "POST", "/safeRestart"); return { success: true }; },
+    });
+    rl.registerAction("instance.exit", {
+        description: "Shut down Jenkins immediately",
+        async execute(_input, ctx) { await jk(ctx, "POST", "/exit"); return { success: true }; },
+    });
+    rl.registerAction("instance.safeExit", {
+        description: "Shut down Jenkins after running builds finish",
+        async execute(_input, ctx) { await jk(ctx, "POST", "/safeExit"); return { success: true }; },
+    });
+}

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

@@ -0,0 +1,229 @@
+async function apiRequest(domain, email, apiToken, method, endpoint, body, qs) {
+    const url = new URL(`${domain}/rest${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: `Basic ${btoa(`${email}:${apiToken}`)}`, "Content-Type": "application/json", Accept: "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(`Jira 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 {
+        domain: ctx.connection.config.domain.replace(/\/$/, ""),
+        email: ctx.connection.config.email,
+        apiToken: ctx.connection.config.apiToken,
+    };
+}
+function jr(ctx, method, endpoint, body, qs) {
+    const { domain, email, apiToken } = getConn(ctx);
+    return apiRequest(domain, email, apiToken, method, endpoint, body, qs);
+}
+export default function jira(rl) {
+    rl.setName("jira");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        domain: { type: "string", required: true, description: "Jira domain (e.g. https://mycompany.atlassian.net)", env: "JIRA_DOMAIN" },
+        email: { type: "string", required: true, description: "Jira account email", env: "JIRA_EMAIL" },
+        apiToken: { type: "string", required: true, description: "Jira API token", env: "JIRA_API_TOKEN" },
+    });
+    // ── Issue ───────────────────────────────────────────
+    rl.registerAction("issue.create", {
+        description: "Create an issue",
+        inputSchema: {
+            projectKey: { type: "string", required: true, description: "Project key (e.g. PROJ)" },
+            issueType: { type: "string", required: true, description: "Issue type (Bug, Task, Story, Epic...)" },
+            summary: { type: "string", required: true, description: "Issue summary" },
+            description: { type: "string", required: false, description: "Description" },
+            assigneeId: { type: "string", required: false, description: "Assignee account ID" },
+            priority: { type: "string", required: false, description: "Priority name (Highest, High, Medium, Low, Lowest)" },
+            labels: { type: "array", required: false, description: "Labels" },
+            parentKey: { type: "string", required: false, description: "Parent issue key (for subtasks)" },
+            customFields: { type: "object", required: false, description: "Custom fields" },
+        },
+        async execute(input, ctx) {
+            const { projectKey, issueType, summary, description: desc, assigneeId, priority, labels, parentKey, customFields } = input;
+            const fields = {
+                project: { key: projectKey },
+                issuetype: { name: issueType },
+                summary,
+            };
+            if (desc)
+                fields.description = desc;
+            if (assigneeId)
+                fields.assignee = { accountId: assigneeId };
+            if (priority)
+                fields.priority = { name: priority };
+            if (labels)
+                fields.labels = labels;
+            if (parentKey)
+                fields.parent = { key: parentKey };
+            if (customFields)
+                Object.assign(fields, customFields);
+            return jr(ctx, "POST", "/api/2/issue", { fields });
+        },
+    });
+    rl.registerAction("issue.get", {
+        description: "Get an issue",
+        inputSchema: {
+            issueKey: { type: "string", required: true, description: "Issue key (e.g. PROJ-123)" },
+            fields: { type: "string", required: false, description: "Comma-separated fields to return" },
+            expand: { type: "string", required: false, description: "Comma-separated expansions" },
+        },
+        async execute(input, ctx) {
+            const { issueKey, fields, expand } = (input ?? {});
+            const qs = {};
+            if (fields)
+                qs.fields = fields;
+            if (expand)
+                qs.expand = expand;
+            return jr(ctx, "GET", `/api/2/issue/${issueKey}`, undefined, qs);
+        },
+    });
+    rl.registerAction("issue.search", {
+        description: "Search issues using JQL",
+        inputSchema: {
+            jql: { type: "string", required: true, description: "JQL query" },
+            fields: { type: "array", required: false, description: "Fields to return" },
+            maxResults: { type: "number", required: false, description: "Max results" },
+            startAt: { type: "number", required: false, description: "Start index" },
+        },
+        async execute(input, ctx) {
+            const { jql, fields, maxResults, startAt } = input;
+            const body = { jql };
+            if (fields)
+                body.fields = fields;
+            if (maxResults)
+                body.maxResults = maxResults;
+            if (startAt)
+                body.startAt = startAt;
+            return jr(ctx, "POST", "/api/2/search", body);
+        },
+    });
+    rl.registerAction("issue.update", {
+        description: "Update an issue",
+        inputSchema: {
+            issueKey: { type: "string", required: true, description: "Issue key" },
+            fields: { type: "object", required: false, description: "Fields to set" },
+            update: { type: "object", required: false, description: "Update operations" },
+            transition: { type: "object", required: false, description: "Transition {id}" },
+        },
+        async execute(input, ctx) {
+            const { issueKey, fields, update, transition } = input;
+            const body = {};
+            if (fields)
+                body.fields = fields;
+            if (update)
+                body.update = update;
+            if (transition)
+                body.transition = transition;
+            return jr(ctx, "PUT", `/api/2/issue/${issueKey}`, body);
+        },
+    });
+    rl.registerAction("issue.delete", {
+        description: "Delete an issue",
+        inputSchema: { issueKey: { type: "string", required: true, description: "Issue key" } },
+        async execute(input, ctx) { await jr(ctx, "DELETE", `/api/2/issue/${input.issueKey}`); return { success: true }; },
+    });
+    rl.registerAction("issue.transition", {
+        description: "Transition an issue to a new status",
+        inputSchema: {
+            issueKey: { type: "string", required: true, description: "Issue key" },
+            transitionId: { type: "string", required: true, description: "Transition ID" },
+            comment: { type: "string", required: false, description: "Comment to add" },
+        },
+        async execute(input, ctx) {
+            const { issueKey, transitionId, comment } = input;
+            const body = { transition: { id: transitionId } };
+            if (comment)
+                body.update = { comment: [{ add: { body: comment } }] };
+            return jr(ctx, "POST", `/api/2/issue/${issueKey}/transitions`, body);
+        },
+    });
+    rl.registerAction("issue.getTransitions", {
+        description: "Get available transitions for an issue",
+        inputSchema: { issueKey: { type: "string", required: true, description: "Issue key" } },
+        async execute(input, ctx) { return jr(ctx, "GET", `/api/2/issue/${input.issueKey}/transitions`); },
+    });
+    rl.registerAction("issue.getChangelog", {
+        description: "Get issue changelog",
+        inputSchema: { issueKey: { type: "string", required: true, description: "Issue key" } },
+        async execute(input, ctx) { return jr(ctx, "GET", `/api/2/issue/${input.issueKey}/changelog`); },
+    });
+    rl.registerAction("issue.notify", {
+        description: "Send notification about an issue",
+        inputSchema: {
+            issueKey: { type: "string", required: true, description: "Issue key" },
+            subject: { type: "string", required: true, description: "Email subject" },
+            htmlBody: { type: "string", required: true, description: "HTML body" },
+            to: { type: "object", required: true, description: "{users: [{accountId}], groups: [{name}]}" },
+        },
+        async execute(input, ctx) {
+            const { issueKey, subject, htmlBody, to } = input;
+            return jr(ctx, "POST", `/api/2/issue/${issueKey}/notify`, { subject, htmlBody, to });
+        },
+    });
+    // ── Issue Comment ───────────────────────────────────
+    rl.registerAction("issueComment.add", {
+        description: "Add a comment to an issue",
+        inputSchema: {
+            issueKey: { type: "string", required: true, description: "Issue key" },
+            body: { type: "string", required: true, description: "Comment body" },
+        },
+        async execute(input, ctx) {
+            const { issueKey, body: commentBody } = input;
+            return jr(ctx, "POST", `/api/2/issue/${issueKey}/comment`, { body: commentBody });
+        },
+    });
+    rl.registerAction("issueComment.get", {
+        description: "Get a comment",
+        inputSchema: { issueKey: { type: "string", required: true, description: "Issue key" }, commentId: { type: "string", required: true, description: "Comment ID" } },
+        async execute(input, ctx) { const { issueKey, commentId } = input; return jr(ctx, "GET", `/api/2/issue/${issueKey}/comment/${commentId}`); },
+    });
+    rl.registerAction("issueComment.list", {
+        description: "List comments on an issue",
+        inputSchema: { issueKey: { type: "string", required: true, description: "Issue key" } },
+        async execute(input, ctx) { return jr(ctx, "GET", `/api/2/issue/${input.issueKey}/comment`); },
+    });
+    rl.registerAction("issueComment.update", {
+        description: "Update a comment",
+        inputSchema: { issueKey: { type: "string", required: true, description: "Issue key" }, commentId: { type: "string", required: true, description: "Comment ID" }, body: { type: "string", required: true, description: "New body" } },
+        async execute(input, ctx) { const { issueKey, commentId, body: b } = input; return jr(ctx, "PUT", `/api/2/issue/${issueKey}/comment/${commentId}`, { body: b }); },
+    });
+    rl.registerAction("issueComment.delete", {
+        description: "Delete a comment",
+        inputSchema: { issueKey: { type: "string", required: true, description: "Issue key" }, commentId: { type: "string", required: true, description: "Comment ID" } },
+        async execute(input, ctx) { const { issueKey, commentId } = input; await jr(ctx, "DELETE", `/api/2/issue/${issueKey}/comment/${commentId}`); return { success: true }; },
+    });
+    // ── User ────────────────────────────────────────────
+    rl.registerAction("user.get", {
+        description: "Get a user by account ID",
+        inputSchema: { accountId: { type: "string", required: true, description: "Account ID" } },
+        async execute(input, ctx) { return jr(ctx, "GET", "/api/2/user", undefined, { accountId: input.accountId }); },
+    });
+    rl.registerAction("user.search", {
+        description: "Search users",
+        inputSchema: { query: { type: "string", required: true, description: "Search query" }, maxResults: { type: "number", required: false, description: "Max results" } },
+        async execute(input, ctx) {
+            const { query, maxResults } = input;
+            const qs = { query };
+            if (maxResults)
+                qs.maxResults = maxResults;
+            return jr(ctx, "GET", "/api/2/user/search", undefined, qs);
+        },
+    });
+}