runline 0.1.0

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

@@ -0,0 +1,233 @@
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    const base = (c.url ?? "https://sentry.io").replace(/\/$/, "");
+    return { base, token: c.token };
+}
+async function apiRequest(conn, method, endpoint, body, qs) {
+    const url = new URL(`${conn.base}${endpoint}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const init = { method, headers: { Authorization: `Bearer ${conn.token}`, "Content-Type": "application/json" } };
+    if (body && Object.keys(body).length > 0)
+        init.body = JSON.stringify(body);
+    const res = await fetch(url.toString(), init);
+    if (!res.ok)
+        throw new Error(`Sentry error ${res.status}: ${await res.text()}`);
+    const text = await res.text();
+    return text ? JSON.parse(text) : {};
+}
+function registerCrud(rl, resource, basePath, idField, extraCreateFields) {
+    rl.registerAction(`${resource}.get`, {
+        description: `Get a ${resource} by ${idField}`,
+        inputSchema: { [idField]: { type: "string", required: true }, org: { type: "string", required: true, description: "Organization slug" } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(getConn(ctx), "GET", `${basePath(p)}${p[idField]}/`);
+        },
+    });
+    rl.registerAction(`${resource}.list`, {
+        description: `List ${resource}s`,
+        inputSchema: { org: { type: "string", required: true }, limit: { type: "number", required: false }, ...(resource === "event" || resource === "issue" ? { project: { type: "string", required: true, description: "Project slug" } } : {}) },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.limit)
+                qs.limit = p.limit;
+            const data = (await apiRequest(getConn(ctx), "GET", basePath(p), undefined, qs));
+            return data;
+        },
+    });
+    rl.registerAction(`${resource}.delete`, {
+        description: `Delete a ${resource}`,
+        inputSchema: { [idField]: { type: "string", required: true }, org: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            await apiRequest(getConn(ctx), "DELETE", `${basePath(p)}${p[idField]}/`);
+            return { success: true };
+        },
+    });
+}
+export default function sentry(rl) {
+    rl.setName("sentry");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        token: { type: "string", required: true, description: "Sentry auth token (Bearer)", env: "SENTRY_TOKEN" },
+        url: { type: "string", required: false, description: "Sentry base URL (default https://sentry.io)", env: "SENTRY_URL" },
+    });
+    // ── Event ───────────────────────────────────────────
+    rl.registerAction("event.get", {
+        description: "Get a project event by ID",
+        inputSchema: { org: { type: "string", required: true }, project: { type: "string", required: true }, eventId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(getConn(ctx), "GET", `/api/0/projects/${p.org}/${p.project}/events/${p.eventId}/`);
+        },
+    });
+    rl.registerAction("event.list", {
+        description: "List project events",
+        inputSchema: { org: { type: "string", required: true }, project: { type: "string", required: true }, full: { type: "boolean", required: false }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.full)
+                qs.full = "true";
+            if (p.limit)
+                qs.limit = p.limit;
+            return apiRequest(getConn(ctx), "GET", `/api/0/projects/${p.org}/${p.project}/events/`, undefined, qs);
+        },
+    });
+    // ── Issue ───────────────────────────────────────────
+    rl.registerAction("issue.get", {
+        description: "Get an issue by ID",
+        inputSchema: { issueId: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(getConn(ctx), "GET", `/api/0/issues/${input.issueId}/`); },
+    });
+    rl.registerAction("issue.list", {
+        description: "List issues for a project",
+        inputSchema: { org: { type: "string", required: true }, project: { type: "string", required: true }, query: { type: "string", required: false }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.query)
+                qs.query = p.query;
+            if (p.limit)
+                qs.limit = p.limit;
+            return apiRequest(getConn(ctx), "GET", `/api/0/projects/${p.org}/${p.project}/issues/`, undefined, qs);
+        },
+    });
+    rl.registerAction("issue.update", {
+        description: "Update an issue",
+        inputSchema: { issueId: { type: "string", required: true }, status: { type: "string", required: false }, assignedTo: { type: "string", required: false }, hasSeen: { type: "boolean", required: false }, isBookmarked: { type: "boolean", required: false } },
+        async execute(input, ctx) {
+            const { issueId, ...fields } = input;
+            return apiRequest(getConn(ctx), "PUT", `/api/0/issues/${issueId}/`, fields);
+        },
+    });
+    rl.registerAction("issue.delete", {
+        description: "Delete an issue",
+        inputSchema: { issueId: { type: "string", required: true } },
+        async execute(input, ctx) { await apiRequest(getConn(ctx), "DELETE", `/api/0/issues/${input.issueId}/`); return { success: true }; },
+    });
+    // ── Organization ────────────────────────────────────
+    rl.registerAction("organization.get", {
+        description: "Get an organization",
+        inputSchema: { org: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(getConn(ctx), "GET", `/api/0/organizations/${input.org}/`); },
+    });
+    rl.registerAction("organization.list", {
+        description: "List organizations",
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const qs = {};
+            if (input?.limit)
+                qs.limit = input.limit;
+            return apiRequest(getConn(ctx), "GET", "/api/0/organizations/", undefined, qs);
+        },
+    });
+    rl.registerAction("organization.create", {
+        description: "Create an organization",
+        inputSchema: { name: { type: "string", required: true }, slug: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(getConn(ctx), "POST", "/api/0/organizations/", { name: p.name, agreeTerms: true, slug: p.slug });
+        },
+    });
+    // ── Project ─────────────────────────────────────────
+    rl.registerAction("project.get", {
+        description: "Get a project",
+        inputSchema: { org: { type: "string", required: true }, project: { type: "string", required: true } },
+        async execute(input, ctx) { const p = input; return apiRequest(getConn(ctx), "GET", `/api/0/projects/${p.org}/${p.project}/`); },
+    });
+    rl.registerAction("project.list", {
+        description: "List all projects",
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) { return apiRequest(getConn(ctx), "GET", "/api/0/projects/", undefined, input?.limit ? { limit: input.limit } : undefined); },
+    });
+    rl.registerAction("project.create", {
+        description: "Create a project",
+        inputSchema: { org: { type: "string", required: true }, team: { type: "string", required: true }, name: { type: "string", required: true }, slug: { type: "string", required: false }, platform: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { name: p.name };
+            if (p.slug)
+                body.slug = p.slug;
+            if (p.platform)
+                body.platform = p.platform;
+            return apiRequest(getConn(ctx), "POST", `/api/0/teams/${p.org}/${p.team}/projects/`, body);
+        },
+    });
+    rl.registerAction("project.delete", {
+        description: "Delete a project",
+        inputSchema: { org: { type: "string", required: true }, project: { type: "string", required: true } },
+        async execute(input, ctx) { const p = input; await apiRequest(getConn(ctx), "DELETE", `/api/0/projects/${p.org}/${p.project}/`); return { success: true }; },
+    });
+    // ── Release ─────────────────────────────────────────
+    rl.registerAction("release.get", {
+        description: "Get a release",
+        inputSchema: { org: { type: "string", required: true }, version: { type: "string", required: true } },
+        async execute(input, ctx) { const p = input; return apiRequest(getConn(ctx), "GET", `/api/0/organizations/${p.org}/releases/${encodeURIComponent(p.version)}/`); },
+    });
+    rl.registerAction("release.list", {
+        description: "List releases",
+        inputSchema: { org: { type: "string", required: true }, query: { type: "string", required: false }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.query)
+                qs.query = p.query;
+            if (p.limit)
+                qs.limit = p.limit;
+            return apiRequest(getConn(ctx), "GET", `/api/0/organizations/${p.org}/releases/`, undefined, qs);
+        },
+    });
+    rl.registerAction("release.create", {
+        description: "Create a release",
+        inputSchema: { org: { type: "string", required: true }, version: { type: "string", required: true }, projects: { type: "object", required: true, description: "Array of project slugs" }, url: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { version: p.version, projects: p.projects };
+            if (p.url)
+                body.url = p.url;
+            return apiRequest(getConn(ctx), "POST", `/api/0/organizations/${p.org}/releases/`, body);
+        },
+    });
+    rl.registerAction("release.delete", {
+        description: "Delete a release",
+        inputSchema: { org: { type: "string", required: true }, version: { type: "string", required: true } },
+        async execute(input, ctx) { const p = input; await apiRequest(getConn(ctx), "DELETE", `/api/0/organizations/${p.org}/releases/${encodeURIComponent(p.version)}/`); return { success: true }; },
+    });
+    // ── Team ────────────────────────────────────────────
+    rl.registerAction("team.get", {
+        description: "Get a team",
+        inputSchema: { org: { type: "string", required: true }, team: { type: "string", required: true } },
+        async execute(input, ctx) { const p = input; return apiRequest(getConn(ctx), "GET", `/api/0/teams/${p.org}/${p.team}/`); },
+    });
+    rl.registerAction("team.list", {
+        description: "List teams in an organization",
+        inputSchema: { org: { type: "string", required: true }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            return apiRequest(getConn(ctx), "GET", `/api/0/organizations/${p.org}/teams/`, undefined, p.limit ? { limit: p.limit } : undefined);
+        },
+    });
+    rl.registerAction("team.create", {
+        description: "Create a team",
+        inputSchema: { org: { type: "string", required: true }, name: { type: "string", required: true }, slug: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { name: p.name };
+            if (p.slug)
+                body.slug = p.slug;
+            return apiRequest(getConn(ctx), "POST", `/api/0/organizations/${p.org}/teams/`, body);
+        },
+    });
+    rl.registerAction("team.delete", {
+        description: "Delete a team",
+        inputSchema: { org: { type: "string", required: true }, team: { type: "string", required: true } },
+        async execute(input, ctx) { const p = input; await apiRequest(getConn(ctx), "DELETE", `/api/0/teams/${p.org}/${p.team}/`); return { success: true }; },
+    });
+}

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

@@ -0,0 +1,108 @@
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    return { subdomain: c.subdomain, username: c.username, password: c.password };
+}
+async function api(conn, method, endpoint, body, qs) {
+    const url = new URL(`https://${conn.subdomain}.service-now.com/api${endpoint}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const init = { method, headers: { Authorization: `Basic ${btoa(`${conn.username}:${conn.password}`)}`, "Content-Type": "application/json", Accept: "application/json" } };
+    if (body && Object.keys(body).length > 0)
+        init.body = JSON.stringify(body);
+    const res = await fetch(url.toString(), init);
+    if (!res.ok)
+        throw new Error(`ServiceNow error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+const TABLES = {
+    incident: "incident", user: "sys_user", userGroup: "sys_user_group", userRole: "sys_user_role",
+    businessService: "cmdb_ci_service", configurationItem: "cmdb_ci", department: "cmn_department",
+};
+function registerTableResource(rl, resource, table, conn) {
+    rl.registerAction(`${resource}.create`, { description: `Create a ${resource}`, inputSchema: { data: { type: "object", required: true } },
+        async execute(input, ctx) {
+            const data = (await api(conn(ctx), "POST", `/now/table/${table}`, input.data));
+            return data.result;
+        } });
+    rl.registerAction(`${resource}.get`, { description: `Get a ${resource} by sys_id`, inputSchema: { sysId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = (await api(conn(ctx), "GET", `/now/table/${table}/${input.sysId}`));
+            return data.result;
+        } });
+    rl.registerAction(`${resource}.list`, { description: `List ${resource}s`, inputSchema: { limit: { type: "number", required: false }, query: { type: "string", required: false, description: "Encoded query string" }, fields: { type: "string", required: false, description: "Comma-separated fields" } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.limit)
+                qs.sysparm_limit = p.limit;
+            if (p.query)
+                qs.sysparm_query = p.query;
+            if (p.fields)
+                qs.sysparm_fields = p.fields;
+            const data = (await api(conn(ctx), "GET", `/now/table/${table}`, undefined, qs));
+            return data.result;
+        } });
+    rl.registerAction(`${resource}.update`, { description: `Update a ${resource}`, inputSchema: { sysId: { type: "string", required: true }, data: { type: "object", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            const data = (await api(conn(ctx), "PATCH", `/now/table/${table}/${p.sysId}`, p.data));
+            return data.result;
+        } });
+    rl.registerAction(`${resource}.delete`, { description: `Delete a ${resource}`, inputSchema: { sysId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            await api(conn(ctx), "DELETE", `/now/table/${table}/${input.sysId}`);
+            return { success: true };
+        } });
+}
+export default function servicenow(rl) {
+    rl.setName("servicenow");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        subdomain: { type: "string", required: true, description: "ServiceNow instance subdomain", env: "SERVICENOW_SUBDOMAIN" },
+        username: { type: "string", required: true, description: "ServiceNow username", env: "SERVICENOW_USERNAME" },
+        password: { type: "string", required: true, description: "ServiceNow password", env: "SERVICENOW_PASSWORD" },
+    });
+    for (const [resource, table] of Object.entries(TABLES)) {
+        registerTableResource(rl, resource, table, getConn);
+    }
+    // ── Generic Table Record ────────────────────────────
+    rl.registerAction("tableRecord.create", { description: "Create a record in any table", inputSchema: { tableName: { type: "string", required: true }, data: { type: "object", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            const data = (await api(getConn(ctx), "POST", `/now/table/${p.tableName}`, p.data));
+            return data.result;
+        } });
+    rl.registerAction("tableRecord.get", { description: "Get a record from any table", inputSchema: { tableName: { type: "string", required: true }, sysId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            const data = (await api(getConn(ctx), "GET", `/now/table/${p.tableName}/${p.sysId}`));
+            return data.result;
+        } });
+    rl.registerAction("tableRecord.list", { description: "List records from any table", inputSchema: { tableName: { type: "string", required: true }, limit: { type: "number", required: false }, query: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const qs = {};
+            if (p.limit)
+                qs.sysparm_limit = p.limit;
+            if (p.query)
+                qs.sysparm_query = p.query;
+            const data = (await api(getConn(ctx), "GET", `/now/table/${p.tableName}`, undefined, qs));
+            return data.result;
+        } });
+    rl.registerAction("tableRecord.update", { description: "Update a record in any table", inputSchema: { tableName: { type: "string", required: true }, sysId: { type: "string", required: true }, data: { type: "object", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            const data = (await api(getConn(ctx), "PATCH", `/now/table/${p.tableName}/${p.sysId}`, p.data));
+            return data.result;
+        } });
+    rl.registerAction("tableRecord.delete", { description: "Delete a record from any table", inputSchema: { tableName: { type: "string", required: true }, sysId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            await api(getConn(ctx), "DELETE", `/now/table/${p.tableName}/${p.sysId}`);
+            return { success: true };
+        } });
+}

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

@@ -0,0 +1,222 @@
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    const subdomain = c.shopSubdomain;
+    const base = `https://${subdomain}.myshopify.com/admin/api/2024-07`;
+    return { base, accessToken: c.accessToken };
+}
+async function apiRequest(conn, method, endpoint, body, qs) {
+    const url = new URL(`${conn.base}${endpoint}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const init = {
+        method,
+        headers: { "X-Shopify-Access-Token": conn.accessToken, "Content-Type": "application/json" },
+    };
+    if (body !== undefined)
+        init.body = JSON.stringify(body);
+    const res = await fetch(url.toString(), init);
+    if (!res.ok)
+        throw new Error(`Shopify error ${res.status}: ${await res.text()}`);
+    const text = await res.text();
+    return text ? JSON.parse(text) : {};
+}
+async function paginate(conn, propertyName, endpoint, qs = {}) {
+    const all = [];
+    let nextUrl;
+    do {
+        const url = nextUrl ?? `${conn.base}${endpoint}`;
+        const u = new URL(url);
+        if (!nextUrl && qs) {
+            for (const [k, v] of Object.entries(qs)) {
+                if (v !== undefined && v !== null)
+                    u.searchParams.set(k, String(v));
+            }
+        }
+        const res = await fetch(u.toString(), {
+            headers: { "X-Shopify-Access-Token": conn.accessToken },
+        });
+        if (!res.ok)
+            throw new Error(`Shopify error ${res.status}: ${await res.text()}`);
+        const data = (await res.json());
+        all.push(...(data[propertyName] ?? []));
+        nextUrl = undefined;
+        const link = res.headers.get("link") ?? "";
+        if (link.includes('rel="next"')) {
+            const match = link.match(/<([^>]+)>;\s*rel="next"/);
+            if (match)
+                nextUrl = match[1];
+        }
+    } while (nextUrl);
+    return all;
+}
+export default function shopify(rl) {
+    rl.setName("shopify");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        shopSubdomain: { type: "string", required: true, description: "Shopify store subdomain (e.g. mystore)", env: "SHOPIFY_SUBDOMAIN" },
+        accessToken: { type: "string", required: true, description: "Shopify Admin API access token", env: "SHOPIFY_ACCESS_TOKEN" },
+    });
+    // ── Order ───────────────────────────────────────────
+    rl.registerAction("order.create", {
+        description: "Create an order",
+        inputSchema: {
+            lineItems: { type: "object", required: true, description: "Array of line item objects [{variant_id, quantity}]" },
+            email: { type: "string", required: false },
+            note: { type: "string", required: false },
+            tags: { type: "string", required: false },
+            test: { type: "boolean", required: false, description: "Mark as test order (default true)" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const order = { line_items: p.lineItems, test: p.test !== false };
+            if (p.email)
+                order.email = p.email;
+            if (p.note)
+                order.note = p.note;
+            if (p.tags)
+                order.tags = p.tags;
+            const data = (await apiRequest(getConn(ctx), "POST", "/orders.json", { order }));
+            return data.order;
+        },
+    });
+    rl.registerAction("order.get", {
+        description: "Get an order by ID",
+        inputSchema: { orderId: { type: "string", required: true }, fields: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const qs = {};
+            if (p.fields)
+                qs.fields = p.fields;
+            const data = (await apiRequest(getConn(ctx), "GET", `/orders/${p.orderId}.json`, undefined, qs));
+            return data.order;
+        },
+    });
+    rl.registerAction("order.list", {
+        description: "List orders",
+        inputSchema: {
+            status: { type: "string", required: false, description: "open, closed, cancelled, any" },
+            limit: { type: "number", required: false },
+            createdAtMin: { type: "string", required: false },
+            createdAtMax: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const conn = getConn(ctx);
+            const qs = {};
+            if (p.status)
+                qs.status = p.status;
+            if (p.createdAtMin)
+                qs.created_at_min = p.createdAtMin;
+            if (p.createdAtMax)
+                qs.created_at_max = p.createdAtMax;
+            if (p.limit) {
+                qs.limit = p.limit;
+                const d = (await apiRequest(conn, "GET", "/orders.json", undefined, qs));
+                return d.orders;
+            }
+            return paginate(conn, "orders", "/orders.json", qs);
+        },
+    });
+    rl.registerAction("order.update", {
+        description: "Update an order",
+        inputSchema: {
+            orderId: { type: "string", required: true },
+            note: { type: "string", required: false },
+            tags: { type: "string", required: false },
+            email: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const order = {};
+            if (p.note !== undefined)
+                order.note = p.note;
+            if (p.tags)
+                order.tags = p.tags;
+            if (p.email)
+                order.email = p.email;
+            const data = (await apiRequest(getConn(ctx), "PUT", `/orders/${p.orderId}.json`, { order }));
+            return data.order;
+        },
+    });
+    rl.registerAction("order.delete", {
+        description: "Delete an order",
+        inputSchema: { orderId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            await apiRequest(getConn(ctx), "DELETE", `/orders/${input.orderId}.json`);
+            return { success: true };
+        },
+    });
+    // ── Product ─────────────────────────────────────────
+    rl.registerAction("product.create", {
+        description: "Create a product",
+        inputSchema: {
+            title: { type: "string", required: true },
+            body_html: { type: "string", required: false },
+            vendor: { type: "string", required: false },
+            product_type: { type: "string", required: false },
+            tags: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const data = (await apiRequest(getConn(ctx), "POST", "/products.json", { product: p }));
+            return data.product;
+        },
+    });
+    rl.registerAction("product.get", {
+        description: "Get a product by ID",
+        inputSchema: { productId: { type: "string", required: true }, fields: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const qs = {};
+            if (p.fields)
+                qs.fields = p.fields;
+            const data = (await apiRequest(getConn(ctx), "GET", `/products/${p.productId}.json`, undefined, qs));
+            return data.product;
+        },
+    });
+    rl.registerAction("product.list", {
+        description: "List products",
+        inputSchema: { limit: { type: "number", required: false }, title: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const conn = getConn(ctx);
+            const qs = {};
+            if (p.title)
+                qs.title = p.title;
+            if (p.limit) {
+                qs.limit = p.limit;
+                const d = (await apiRequest(conn, "GET", "/products.json", undefined, qs));
+                return d.products;
+            }
+            return paginate(conn, "products", "/products.json", qs);
+        },
+    });
+    rl.registerAction("product.update", {
+        description: "Update a product",
+        inputSchema: {
+            productId: { type: "string", required: true },
+            title: { type: "string", required: false },
+            body_html: { type: "string", required: false },
+            vendor: { type: "string", required: false },
+            tags: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const { productId, ...fields } = p;
+            const data = (await apiRequest(getConn(ctx), "PUT", `/products/${productId}.json`, { product: fields }));
+            return data.product;
+        },
+    });
+    rl.registerAction("product.delete", {
+        description: "Delete a product",
+        inputSchema: { productId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            await apiRequest(getConn(ctx), "DELETE", `/products/${input.productId}.json`);
+            return { success: true };
+        },
+    });
+}

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

@@ -0,0 +1,61 @@
+export default function signl4(rl) {
+    rl.setName("signl4");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        teamSecret: { type: "string", required: true, description: "SIGNL4 team secret (webhook path)", env: "SIGNL4_TEAM_SECRET" },
+    });
+    const url = (ctx) => `https://connect.signl4.com/webhook/${ctx.connection.config.teamSecret}`;
+    rl.registerAction("alert.send", {
+        description: "Send a SIGNL4 alert",
+        inputSchema: {
+            message: { type: "string", required: true },
+            title: { type: "string", required: false },
+            service: { type: "string", required: false },
+            externalId: { type: "string", required: false, description: "External ID for correlation" },
+            alertingScenario: { type: "string", required: false, description: "single_ack or multi_ack" },
+            latitude: { type: "string", required: false },
+            longitude: { type: "string", required: false },
+            filtering: { type: "boolean", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const form = new URLSearchParams();
+            form.set("message", p.message);
+            form.set("X-S4-Status", "new");
+            form.set("X-S4-SourceSystem", "runline");
+            if (p.title)
+                form.set("title", p.title);
+            if (p.service)
+                form.set("service", p.service);
+            if (p.externalId)
+                form.set("X-S4-ExternalID", p.externalId);
+            if (p.alertingScenario)
+                form.set("X-S4-AlertingScenario", p.alertingScenario);
+            if (p.latitude && p.longitude)
+                form.set("X-S4-Location", `${p.latitude},${p.longitude}`);
+            if (p.filtering !== undefined)
+                form.set("X-S4-Filtering", String(p.filtering));
+            const res = await fetch(url(ctx), { method: "POST", body: form });
+            if (!res.ok)
+                throw new Error(`SIGNL4 error ${res.status}: ${await res.text()}`);
+            return res.json();
+        },
+    });
+    rl.registerAction("alert.resolve", {
+        description: "Resolve a SIGNL4 alert by external ID",
+        inputSchema: {
+            externalId: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            const { externalId } = input;
+            const form = new URLSearchParams();
+            form.set("X-S4-ExternalID", externalId);
+            form.set("X-S4-Status", "resolved");
+            form.set("X-S4-SourceSystem", "runline");
+            const res = await fetch(url(ctx), { method: "POST", body: form });
+            if (!res.ok)
+                throw new Error(`SIGNL4 error ${res.status}: ${await res.text()}`);
+            return res.json();
+        },
+    });
+}