runline 0.1.0

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

@@ -0,0 +1,281 @@
+async function apiRequest(baseUrl, token, method, endpoint, body, 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 opts = {
+        method,
+        headers: { Authorization: `Token ${token}`, Accept: "application/json", "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(`KoBoToolbox API error ${res.status}: ${await res.text()}`);
+    if (res.status === 204)
+        return { success: true };
+    return res.json();
+}
+async function paginate(baseUrl, token, endpoint, qs = {}) {
+    const all = [];
+    qs.limit = 3000;
+    let nextUrl = `${baseUrl}${endpoint}`;
+    const initialUrl = new URL(nextUrl);
+    for (const [k, v] of Object.entries(qs)) {
+        if (v !== undefined && v !== null)
+            initialUrl.searchParams.set(k, String(v));
+    }
+    nextUrl = initialUrl.toString();
+    while (nextUrl) {
+        const res = await fetch(nextUrl, {
+            headers: { Authorization: `Token ${token}`, Accept: "application/json" },
+        });
+        if (!res.ok)
+            throw new Error(`KoBoToolbox API error ${res.status}: ${await res.text()}`);
+        const data = (await res.json());
+        if (data.results && Array.isArray(data.results)) {
+            all.push(...data.results);
+            nextUrl = data.next ?? null;
+        }
+        else {
+            // Non-paginated response
+            return Array.isArray(data) ? data : [data];
+        }
+    }
+    return all;
+}
+export default function kobotoolbox(rl) {
+    rl.setName("kobotoolbox");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        url: { type: "string", required: true, description: "KoBoToolbox server URL (e.g. https://kf.kobotoolbox.org)", env: "KOBOTOOLBOX_URL" },
+        token: { type: "string", required: true, description: "API token", env: "KOBOTOOLBOX_TOKEN" },
+    });
+    const conn = (ctx) => ({
+        baseUrl: ctx.connection.config.url.replace(/\/$/, ""),
+        token: ctx.connection.config.token,
+    });
+    // ── Form ────────────────────────────────────────────
+    rl.registerAction("form.get", {
+        description: "Get a form (asset) by ID",
+        inputSchema: { formId: { type: "string", required: true, description: "Form/asset UID" } },
+        async execute(input, ctx) {
+            const { baseUrl, token } = conn(ctx);
+            return apiRequest(baseUrl, token, "GET", `/api/v2/assets/${input.formId}`);
+        },
+    });
+    rl.registerAction("form.list", {
+        description: "List all forms/assets",
+        inputSchema: {
+            limit: { type: "number", required: false },
+            filter: { type: "string", required: false, description: "Search query (q parameter)" },
+            ordering: { type: "string", required: false, description: "Field to sort by" },
+            descending: { type: "boolean", required: false, description: "Sort descending" },
+        },
+        async execute(input, ctx) {
+            const { baseUrl, token } = conn(ctx);
+            const p = (input ?? {});
+            const qs = {};
+            if (p.filter)
+                qs.q = p.filter;
+            if (p.ordering)
+                qs.ordering = (p.descending ? "-" : "") + p.ordering;
+            if (p.limit) {
+                qs.limit = p.limit;
+                return apiRequest(baseUrl, token, "GET", "/api/v2/assets/", undefined, qs);
+            }
+            return paginate(baseUrl, token, "/api/v2/assets/", qs);
+        },
+    });
+    rl.registerAction("form.redeploy", {
+        description: "Redeploy a form",
+        inputSchema: { formId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { baseUrl, token } = conn(ctx);
+            return apiRequest(baseUrl, token, "PATCH", `/api/v2/assets/${input.formId}/deployment/`);
+        },
+    });
+    // ── Submission ──────────────────────────────────────
+    rl.registerAction("submission.get", {
+        description: "Get a submission by ID",
+        inputSchema: {
+            formId: { type: "string", required: true },
+            submissionId: { type: "string", required: true },
+            fields: { type: "array", required: false, description: "Fields to include" },
+        },
+        async execute(input, ctx) {
+            const { formId, submissionId, fields } = input;
+            const { baseUrl, token } = conn(ctx);
+            const qs = {};
+            if (fields && Array.isArray(fields))
+                qs.fields = JSON.stringify(fields);
+            return apiRequest(baseUrl, token, "GET", `/api/v2/assets/${formId}/data/${submissionId}`, undefined, qs);
+        },
+    });
+    rl.registerAction("submission.list", {
+        description: "List submissions for a form",
+        inputSchema: {
+            formId: { type: "string", required: true },
+            limit: { type: "number", required: false },
+            query: { type: "string", required: false, description: "JSON filter query" },
+            sort: { type: "string", required: false, description: "Sort JSON" },
+            fields: { type: "array", required: false, description: "Fields to include" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const { baseUrl, token } = conn(ctx);
+            const qs = {};
+            if (p.query)
+                qs.query = p.query;
+            if (p.sort)
+                qs.sort = p.sort;
+            if (p.fields && Array.isArray(p.fields))
+                qs.fields = JSON.stringify(p.fields);
+            if (p.limit) {
+                qs.limit = p.limit;
+                const data = await apiRequest(baseUrl, token, "GET", `/api/v2/assets/${p.formId}/data/`, undefined, qs);
+                return data.results ?? data;
+            }
+            return paginate(baseUrl, token, `/api/v2/assets/${p.formId}/data/`, qs);
+        },
+    });
+    rl.registerAction("submission.delete", {
+        description: "Delete a submission",
+        inputSchema: { formId: { type: "string", required: true }, submissionId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { formId, submissionId } = input;
+            const { baseUrl, token } = conn(ctx);
+            await apiRequest(baseUrl, token, "DELETE", `/api/v2/assets/${formId}/data/${submissionId}`);
+            return { success: true };
+        },
+    });
+    rl.registerAction("submission.getValidation", {
+        description: "Get the validation status of a submission",
+        inputSchema: { formId: { type: "string", required: true }, submissionId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { formId, submissionId } = input;
+            const { baseUrl, token } = conn(ctx);
+            return apiRequest(baseUrl, token, "GET", `/api/v2/assets/${formId}/data/${submissionId}/validation_status/`);
+        },
+    });
+    rl.registerAction("submission.setValidation", {
+        description: "Set the validation status of a submission",
+        inputSchema: {
+            formId: { type: "string", required: true },
+            submissionId: { type: "string", required: true },
+            validationStatus: { type: "string", required: true, description: "validation_status_not_approved, validation_status_approved, validation_status_on_hold" },
+        },
+        async execute(input, ctx) {
+            const { formId, submissionId, validationStatus } = input;
+            const { baseUrl, token } = conn(ctx);
+            return apiRequest(baseUrl, token, "PATCH", `/api/v2/assets/${formId}/data/${submissionId}/validation_status/`, { "validation_status.uid": validationStatus });
+        },
+    });
+    // ── Hook ────────────────────────────────────────────
+    rl.registerAction("hook.get", {
+        description: "Get a hook by ID",
+        inputSchema: { formId: { type: "string", required: true }, hookId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { formId, hookId } = input;
+            const { baseUrl, token } = conn(ctx);
+            return apiRequest(baseUrl, token, "GET", `/api/v2/assets/${formId}/hooks/${hookId}`);
+        },
+    });
+    rl.registerAction("hook.list", {
+        description: "List hooks for a form",
+        inputSchema: { formId: { type: "string", required: true }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const { formId, limit } = input;
+            const { baseUrl, token } = conn(ctx);
+            if (limit)
+                return apiRequest(baseUrl, token, "GET", `/api/v2/assets/${formId}/hooks/`, undefined, { limit });
+            return paginate(baseUrl, token, `/api/v2/assets/${formId}/hooks/`);
+        },
+    });
+    rl.registerAction("hook.retryAll", {
+        description: "Retry all failed attempts for a hook",
+        inputSchema: { formId: { type: "string", required: true }, hookId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { formId, hookId } = input;
+            const { baseUrl, token } = conn(ctx);
+            return apiRequest(baseUrl, token, "PATCH", `/api/v2/assets/${formId}/hooks/${hookId}/retry/`);
+        },
+    });
+    rl.registerAction("hook.getLogs", {
+        description: "Get logs for a hook",
+        inputSchema: {
+            formId: { type: "string", required: true },
+            hookId: { type: "string", required: true },
+            startDate: { type: "string", required: false, description: "Start date filter" },
+            endDate: { type: "string", required: false, description: "End date filter" },
+            status: { type: "number", required: false, description: "HTTP status code filter" },
+        },
+        async execute(input, ctx) {
+            const { formId, hookId, startDate, endDate, status } = input;
+            const { baseUrl, token } = conn(ctx);
+            const qs = {};
+            if (startDate)
+                qs.start = startDate;
+            if (endDate)
+                qs.end = endDate;
+            if (status)
+                qs.status = status;
+            return apiRequest(baseUrl, token, "GET", `/api/v2/assets/${formId}/hooks/${hookId}/logs/`, undefined, qs);
+        },
+    });
+    rl.registerAction("hook.retryOne", {
+        description: "Retry a single failed hook log entry",
+        inputSchema: { formId: { type: "string", required: true }, hookId: { type: "string", required: true }, logId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { formId, hookId, logId } = input;
+            const { baseUrl, token } = conn(ctx);
+            return apiRequest(baseUrl, token, "PATCH", `/api/v2/assets/${formId}/hooks/${hookId}/logs/${logId}/retry/`);
+        },
+    });
+    // ── File ────────────────────────────────────────────
+    rl.registerAction("file.list", {
+        description: "List media files for a form",
+        inputSchema: { formId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { baseUrl, token } = conn(ctx);
+            return paginate(baseUrl, token, `/api/v2/assets/${input.formId}/files`, { file_type: "form_media" });
+        },
+    });
+    rl.registerAction("file.get", {
+        description: "Get a file's metadata",
+        inputSchema: { formId: { type: "string", required: true }, fileId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { formId, fileId } = input;
+            const { baseUrl, token } = conn(ctx);
+            return apiRequest(baseUrl, token, "GET", `/api/v2/assets/${formId}/files/${fileId}`);
+        },
+    });
+    rl.registerAction("file.delete", {
+        description: "Delete a file",
+        inputSchema: { formId: { type: "string", required: true }, fileId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { formId, fileId } = input;
+            const { baseUrl, token } = conn(ctx);
+            return apiRequest(baseUrl, token, "DELETE", `/api/v2/assets/${formId}/files/${fileId}`);
+        },
+    });
+    rl.registerAction("file.createFromUrl", {
+        description: "Create a file from a URL (redirect-based media)",
+        inputSchema: {
+            formId: { type: "string", required: true },
+            redirectUrl: { type: "string", required: true, description: "URL of the file" },
+        },
+        async execute(input, ctx) {
+            const { formId, redirectUrl } = input;
+            const { baseUrl, token } = conn(ctx);
+            return apiRequest(baseUrl, token, "POST", `/api/v2/assets/${formId}/files/`, {
+                description: "Uploaded file",
+                file_type: "form_media",
+                metadata: { redirect_url: redirectUrl },
+            });
+        },
+    });
+}

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

@@ -0,0 +1,231 @@
+const BASE_URL = "https://api.lemlist.com/api";
+async function apiRequest(apiKey, 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: `Basic ${btoa(`:${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(`Lemlist API error ${res.status}: ${await res.text()}`);
+    if (res.status === 204)
+        return { success: true };
+    return res.json();
+}
+async function paginate(apiKey, method, endpoint, qs = {}) {
+    const all = [];
+    qs.limit = 100;
+    qs.offset = 0;
+    let data;
+    do {
+        data = (await apiRequest(apiKey, method, endpoint, undefined, qs));
+        all.push(...data);
+        qs.offset += qs.limit;
+    } while (data.length > 0);
+    return all;
+}
+export default function lemlist(rl) {
+    rl.setName("lemlist");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: { type: "string", required: true, description: "Lemlist API key", env: "LEMLIST_API_KEY" },
+    });
+    const key = (ctx) => ctx.connection.config.apiKey;
+    // ── Activity ────────────────────────────────────────
+    rl.registerAction("activity.list", {
+        description: "List activities",
+        inputSchema: {
+            limit: { type: "number", required: false, description: "Max results" },
+            campaignId: { type: "string", required: false, description: "Filter by campaign ID" },
+            type: { type: "string", required: false, description: "Filter by activity type" },
+            isFirst: { type: "boolean", required: false, description: "Filter first activities only" },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.campaignId)
+                qs.campaignId = p.campaignId;
+            if (p.type)
+                qs.type = p.type;
+            if (p.isFirst !== undefined)
+                qs.isFirst = p.isFirst;
+            if (p.limit) {
+                qs.limit = p.limit;
+                return apiRequest(key(ctx), "GET", "/activities", undefined, qs);
+            }
+            return paginate(key(ctx), "GET", "/activities", qs);
+        },
+    });
+    // ── Campaign ────────────────────────────────────────
+    rl.registerAction("campaign.list", {
+        description: "List campaigns",
+        inputSchema: {
+            limit: { type: "number", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            if (p.limit)
+                return apiRequest(key(ctx), "GET", "/campaigns", undefined, { limit: p.limit });
+            return paginate(key(ctx), "GET", "/campaigns");
+        },
+    });
+    rl.registerAction("campaign.getStats", {
+        description: "Get campaign statistics",
+        inputSchema: {
+            campaignId: { type: "string", required: true },
+            startDate: { type: "string", required: true, description: "Start date (YYYY-MM-DD)" },
+            endDate: { type: "string", required: true, description: "End date (YYYY-MM-DD)" },
+            timezone: { type: "string", required: true, description: "Timezone (e.g. America/New_York)" },
+        },
+        async execute(input, ctx) {
+            const { campaignId, startDate, endDate, timezone } = input;
+            return apiRequest(key(ctx), "GET", `/campaigns/${campaignId}/stats`, undefined, { startDate, endDate, timezone });
+        },
+    });
+    // ── Lead ────────────────────────────────────────────
+    rl.registerAction("lead.create", {
+        description: "Add a lead to a campaign",
+        inputSchema: {
+            campaignId: { type: "string", required: true },
+            email: { type: "string", required: true },
+            deduplicate: { type: "boolean", required: false, description: "Deduplicate by email" },
+            firstName: { type: "string", required: false },
+            lastName: { type: "string", required: false },
+            companyName: { type: "string", required: false },
+            additionalFields: { type: "object", required: false, description: "Any extra fields" },
+        },
+        async execute(input, ctx) {
+            const { campaignId, email, deduplicate, firstName, lastName, companyName, additionalFields } = input;
+            const body = {};
+            if (firstName)
+                body.firstName = firstName;
+            if (lastName)
+                body.lastName = lastName;
+            if (companyName)
+                body.companyName = companyName;
+            if (additionalFields)
+                Object.assign(body, additionalFields);
+            const qs = {};
+            if (deduplicate !== undefined)
+                qs.deduplicate = deduplicate;
+            return apiRequest(key(ctx), "POST", `/campaigns/${campaignId}/leads/${encodeURIComponent(email)}`, body, Object.keys(qs).length > 0 ? qs : undefined);
+        },
+    });
+    rl.registerAction("lead.get", {
+        description: "Get a lead by email",
+        inputSchema: { email: { type: "string", required: true } },
+        async execute(input, ctx) {
+            return apiRequest(key(ctx), "GET", `/leads/${encodeURIComponent(input.email)}`);
+        },
+    });
+    rl.registerAction("lead.delete", {
+        description: "Remove a lead from a campaign (keeps lead in unsubscribe list)",
+        inputSchema: {
+            campaignId: { type: "string", required: true },
+            email: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            const { campaignId, email } = input;
+            return apiRequest(key(ctx), "DELETE", `/campaigns/${campaignId}/leads/${encodeURIComponent(email)}`, undefined, { action: "remove" });
+        },
+    });
+    rl.registerAction("lead.unsubscribe", {
+        description: "Unsubscribe a lead from a campaign",
+        inputSchema: {
+            campaignId: { type: "string", required: true },
+            email: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            const { campaignId, email } = input;
+            return apiRequest(key(ctx), "DELETE", `/campaigns/${campaignId}/leads/${encodeURIComponent(email)}`);
+        },
+    });
+    // ── Team ────────────────────────────────────────────
+    rl.registerAction("team.get", {
+        description: "Get team information",
+        async execute(_input, ctx) { return apiRequest(key(ctx), "GET", "/team"); },
+    });
+    rl.registerAction("team.getCredits", {
+        description: "Get team credits",
+        async execute(_input, ctx) { return apiRequest(key(ctx), "GET", "/team/credits"); },
+    });
+    // ── Unsubscribe ─────────────────────────────────────
+    rl.registerAction("unsubscribe.add", {
+        description: "Add an email to the unsubscribe list",
+        inputSchema: { email: { type: "string", required: true } },
+        async execute(input, ctx) {
+            return apiRequest(key(ctx), "POST", `/unsubscribes/${encodeURIComponent(input.email)}`);
+        },
+    });
+    rl.registerAction("unsubscribe.delete", {
+        description: "Remove an email from the unsubscribe list",
+        inputSchema: { email: { type: "string", required: true } },
+        async execute(input, ctx) {
+            return apiRequest(key(ctx), "DELETE", `/unsubscribes/${encodeURIComponent(input.email)}`);
+        },
+    });
+    rl.registerAction("unsubscribe.list", {
+        description: "List all unsubscribed emails",
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            if (p.limit)
+                return apiRequest(key(ctx), "GET", "/unsubscribes", undefined, { limit: p.limit });
+            return paginate(key(ctx), "GET", "/unsubscribes");
+        },
+    });
+    // ── Enrichment ──────────────────────────────────────
+    rl.registerAction("enrich.get", {
+        description: "Get an enrichment result by ID",
+        inputSchema: { enrichId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            return apiRequest(key(ctx), "GET", `/enrich/${input.enrichId}`);
+        },
+    });
+    rl.registerAction("enrich.lead", {
+        description: "Enrich a lead by ID",
+        inputSchema: {
+            leadId: { type: "string", required: true },
+            findEmail: { type: "boolean", required: true },
+            verifyEmail: { type: "boolean", required: true },
+            linkedinEnrichment: { type: "boolean", required: true },
+            findPhone: { type: "boolean", required: true },
+        },
+        async execute(input, ctx) {
+            const { leadId, findEmail, verifyEmail, linkedinEnrichment, findPhone } = input;
+            return apiRequest(key(ctx), "POST", `/leads/${leadId}/enrich/`, {}, { findEmail, verifyEmail, linkedinEnrichment, findPhone });
+        },
+    });
+    rl.registerAction("enrich.person", {
+        description: "Enrich a person (without existing lead)",
+        inputSchema: {
+            findEmail: { type: "boolean", required: true },
+            verifyEmail: { type: "boolean", required: true },
+            linkedinEnrichment: { type: "boolean", required: true },
+            findPhone: { type: "boolean", required: true },
+            email: { type: "string", required: false },
+            firstName: { type: "string", required: false },
+            lastName: { type: "string", required: false },
+            linkedinUrl: { type: "string", required: false },
+            companyName: { type: "string", required: false },
+            companyDomain: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const { findEmail, verifyEmail, linkedinEnrichment, findPhone, ...rest } = input;
+            const qs = { findEmail, verifyEmail, linkedinEnrichment, findPhone };
+            for (const [k, v] of Object.entries(rest)) {
+                if (v !== undefined && v !== null)
+                    qs[k] = v;
+            }
+            return apiRequest(key(ctx), "POST", "/enrich/", {}, qs);
+        },
+    });
+}

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

@@ -0,0 +1,133 @@
+const GQL_URL = "https://api.linear.app/graphql";
+async function gql(apiKey, query, variables) {
+    const body = { query };
+    if (variables)
+        body.variables = variables;
+    const res = await fetch(GQL_URL, {
+        method: "POST",
+        headers: { Authorization: apiKey, "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok)
+        throw new Error(`Linear API error ${res.status}: ${await res.text()}`);
+    const data = (await res.json());
+    if (data.errors)
+        throw new Error(`Linear GraphQL error: ${JSON.stringify(data.errors)}`);
+    return data.data;
+}
+export default function linear(rl) {
+    rl.setName("linear");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({ apiKey: { type: "string", required: true, description: "Linear API key", env: "LINEAR_API_KEY" } });
+    const key = (ctx) => ctx.connection.config.apiKey;
+    rl.registerAction("issue.create", {
+        description: "Create an issue",
+        inputSchema: {
+            teamId: { type: "string", required: true, description: "Team ID" },
+            title: { type: "string", required: true, description: "Issue title" },
+            description: { type: "string", required: false, description: "Issue description (markdown)" },
+            assigneeId: { type: "string", required: false, description: "Assignee user ID" },
+            priority: { type: "number", required: false, description: "Priority (0=none, 1=urgent, 2=high, 3=medium, 4=low)" },
+            stateId: { type: "string", required: false, description: "Workflow state ID" },
+            labelIds: { type: "array", required: false, description: "Label IDs" },
+            parentId: { type: "string", required: false, description: "Parent issue ID (for sub-issues)" },
+        },
+        async execute(input, ctx) {
+            const { teamId, title, description: desc, assigneeId, priority, stateId, labelIds, parentId } = input;
+            const vars = { teamId, title };
+            if (desc)
+                vars.description = desc;
+            if (assigneeId)
+                vars.assigneeId = assigneeId;
+            if (priority !== undefined)
+                vars.priority = priority;
+            if (stateId)
+                vars.stateId = stateId;
+            if (labelIds)
+                vars.labelIds = labelIds;
+            if (parentId)
+                vars.parentId = parentId;
+            const data = await gql(key(ctx), `mutation($input: IssueCreateInput!) { issueCreate(input: $input) { success issue { id identifier title url } } }`, { input: vars });
+            return data.issueCreate?.issue;
+        },
+    });
+    rl.registerAction("issue.get", {
+        description: "Get an issue by ID",
+        inputSchema: { issueId: { type: "string", required: true, description: "Issue ID" } },
+        async execute(input, ctx) {
+            const data = await gql(key(ctx), `query($id: String!) { issue(id: $id) { id identifier title description url priority state { id name } assignee { id name } labels { nodes { id name } } createdAt updatedAt } }`, { id: input.issueId });
+            return data.issue;
+        },
+    });
+    rl.registerAction("issue.list", {
+        description: "List issues",
+        inputSchema: {
+            limit: { type: "number", required: false, description: "Max results (default: 50)" },
+            teamId: { type: "string", required: false, description: "Filter by team" },
+            assigneeId: { type: "string", required: false, description: "Filter by assignee" },
+        },
+        async execute(input, ctx) {
+            const { limit = 50, teamId, assigneeId } = (input ?? {});
+            let filter = "";
+            const filterParts = [];
+            if (teamId)
+                filterParts.push(`team: { id: { eq: "${teamId}" } }`);
+            if (assigneeId)
+                filterParts.push(`assignee: { id: { eq: "${assigneeId}" } }`);
+            if (filterParts.length > 0)
+                filter = `, filter: { ${filterParts.join(", ")} }`;
+            const data = await gql(key(ctx), `query { issues(first: ${limit}${filter}) { nodes { id identifier title url priority state { name } assignee { name } createdAt } } }`);
+            return data.issues?.nodes;
+        },
+    });
+    rl.registerAction("issue.update", {
+        description: "Update an issue",
+        inputSchema: {
+            issueId: { type: "string", required: true, description: "Issue ID" },
+            title: { type: "string", required: false, description: "New title" },
+            description: { type: "string", required: false, description: "New description" },
+            assigneeId: { type: "string", required: false, description: "Assignee ID" },
+            stateId: { type: "string", required: false, description: "State ID" },
+            priority: { type: "number", required: false, description: "Priority" },
+            labelIds: { type: "array", required: false, description: "Label IDs" },
+        },
+        async execute(input, ctx) {
+            const { issueId, ...fields } = input;
+            const data = await gql(key(ctx), `mutation($id: String!, $input: IssueUpdateInput!) { issueUpdate(id: $id, input: $input) { success issue { id identifier title url } } }`, { id: issueId, input: fields });
+            return data.issueUpdate?.issue;
+        },
+    });
+    rl.registerAction("issue.delete", {
+        description: "Delete an issue",
+        inputSchema: { issueId: { type: "string", required: true, description: "Issue ID" } },
+        async execute(input, ctx) {
+            const data = await gql(key(ctx), `mutation($id: String!) { issueDelete(id: $id) { success } }`, { id: input.issueId });
+            return data.issueDelete;
+        },
+    });
+    rl.registerAction("issue.addComment", {
+        description: "Add a comment to an issue",
+        inputSchema: {
+            issueId: { type: "string", required: true, description: "Issue ID" },
+            body: { type: "string", required: true, description: "Comment body (markdown)" },
+        },
+        async execute(input, ctx) {
+            const { issueId, body: commentBody } = input;
+            const data = await gql(key(ctx), `mutation($input: CommentCreateInput!) { commentCreate(input: $input) { success comment { id body createdAt } } }`, { input: { issueId, body: commentBody } });
+            return data.commentCreate?.comment;
+        },
+    });
+    rl.registerAction("issue.addLink", {
+        description: "Add a link/relation between issues",
+        inputSchema: {
+            issueId: { type: "string", required: true, description: "Source issue ID" },
+            relatedIssueId: { type: "string", required: true, description: "Related issue ID" },
+            type: { type: "string", required: true, description: "Relation type: relates, blocks, duplicate" },
+        },
+        async execute(input, ctx) {
+            const { issueId, relatedIssueId, type } = input;
+            const data = await gql(key(ctx), `mutation($input: IssueRelationCreateInput!) { issueRelationCreate(input: $input) { success } }`, { input: { issueId, relatedIssueId, type } });
+            return data.issueRelationCreate;
+        },
+    });
+}