runline 0.1.0

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

@@ -0,0 +1,476 @@
+async function apiRequest(baseUrl, apiKey, method, endpoint, body) {
+    const opts = {
+        method,
+        headers: { Authorization: apiKey, 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(`${baseUrl}${endpoint}`, opts);
+    if (!res.ok)
+        throw new Error(`MISP API error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+export default function misp(rl) {
+    rl.setName("misp");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        baseUrl: { type: "string", required: true, description: "MISP instance URL", env: "MISP_URL" },
+        apiKey: { type: "string", required: true, description: "MISP API key (Authorization header)", env: "MISP_API_KEY" },
+    });
+    const conn = (ctx) => ({
+        baseUrl: ctx.connection.config.baseUrl.replace(/\/$/, ""),
+        apiKey: ctx.connection.config.apiKey,
+    });
+    const req = (ctx, method, ep, body) => {
+        const c = conn(ctx);
+        return apiRequest(c.baseUrl, c.apiKey, method, ep, body);
+    };
+    // ── Attribute ───────────────────────────────────────
+    rl.registerAction("attribute.create", {
+        description: "Add an attribute to an event",
+        inputSchema: {
+            eventId: { type: "string", required: true },
+            type: { type: "string", required: true, description: "Attribute type (ip-src, domain, md5, etc.)" },
+            value: { type: "string", required: true },
+            additionalFields: { type: "object", required: false, description: "category, comment, to_ids, distribution, sharing_group_id, etc." },
+        },
+        async execute(input, ctx) {
+            const { eventId, type, value, additionalFields } = input;
+            const body = { type, value };
+            if (additionalFields)
+                Object.assign(body, additionalFields);
+            const data = (await req(ctx, "POST", `/attributes/add/${eventId}`, body));
+            return data.Attribute;
+        },
+    });
+    rl.registerAction("attribute.get", {
+        description: "Get an attribute by ID",
+        inputSchema: { attributeId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = (await req(ctx, "GET", `/attributes/view/${input.attributeId}`));
+            return data.Attribute;
+        },
+    });
+    rl.registerAction("attribute.list", {
+        description: "List all attributes",
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            let data = (await req(ctx, "GET", "/attributes"));
+            if (input?.limit)
+                data = data.slice(0, input.limit);
+            return data;
+        },
+    });
+    rl.registerAction("attribute.search", {
+        description: "Search attributes via restSearch",
+        inputSchema: {
+            value: { type: "string", required: false },
+            searchBody: { type: "object", required: false, description: "Full search body (value, type, category, tags, etc.)" },
+        },
+        async execute(input, ctx) {
+            const { value, searchBody } = (input ?? {});
+            const body = searchBody ?? {};
+            if (value)
+                body.value = value;
+            const data = (await req(ctx, "POST", "/attributes/restSearch", body));
+            return data.response?.Attribute ?? [];
+        },
+    });
+    rl.registerAction("attribute.update", {
+        description: "Update an attribute",
+        inputSchema: { attributeId: { type: "string", required: true }, updateFields: { type: "object", required: true } },
+        async execute(input, ctx) {
+            const { attributeId, updateFields } = input;
+            const data = (await req(ctx, "PUT", `/attributes/edit/${attributeId}`, updateFields));
+            return data.Attribute;
+        },
+    });
+    rl.registerAction("attribute.delete", {
+        description: "Delete an attribute",
+        inputSchema: { attributeId: { type: "string", required: true } },
+        async execute(input, ctx) { return req(ctx, "DELETE", `/attributes/delete/${input.attributeId}`); },
+    });
+    // ── Event ───────────────────────────────────────────
+    rl.registerAction("event.create", {
+        description: "Create an event",
+        inputSchema: {
+            orgId: { type: "string", required: true, description: "Organisation ID" },
+            info: { type: "string", required: true, description: "Event description/info" },
+            additionalFields: { type: "object", required: false, description: "distribution, threat_level_id, analysis, date, etc." },
+        },
+        async execute(input, ctx) {
+            const { orgId, info, additionalFields } = input;
+            const body = { org_id: orgId, info };
+            if (additionalFields)
+                Object.assign(body, additionalFields);
+            const data = (await req(ctx, "POST", "/events", body));
+            return data.Event;
+        },
+    });
+    rl.registerAction("event.get", {
+        description: "Get an event by ID",
+        inputSchema: { eventId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = (await req(ctx, "GET", `/events/view/${input.eventId}`));
+            const event = data.Event;
+            delete event.Attribute; // prevent excessive payload
+            return event;
+        },
+    });
+    rl.registerAction("event.list", {
+        description: "List all events",
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            let data = (await req(ctx, "GET", "/events"));
+            if (input?.limit)
+                data = data.slice(0, input.limit);
+            return data;
+        },
+    });
+    rl.registerAction("event.search", {
+        description: "Search events via restSearch",
+        inputSchema: {
+            value: { type: "string", required: false },
+            searchBody: { type: "object", required: false, description: "Full search body" },
+        },
+        async execute(input, ctx) {
+            const { value, searchBody } = (input ?? {});
+            const body = searchBody ?? {};
+            if (value)
+                body.value = value;
+            const data = (await req(ctx, "POST", "/events/restSearch", body));
+            const response = data.response;
+            return response?.map((e) => e.Event) ?? [];
+        },
+    });
+    rl.registerAction("event.update", {
+        description: "Update an event",
+        inputSchema: { eventId: { type: "string", required: true }, updateFields: { type: "object", required: true } },
+        async execute(input, ctx) {
+            const { eventId, updateFields } = input;
+            const data = (await req(ctx, "PUT", `/events/edit/${eventId}`, updateFields));
+            const event = data.Event;
+            delete event.Attribute;
+            return event;
+        },
+    });
+    rl.registerAction("event.publish", {
+        description: "Publish an event",
+        inputSchema: { eventId: { type: "string", required: true } },
+        async execute(input, ctx) { return req(ctx, "POST", `/events/publish/${input.eventId}`); },
+    });
+    rl.registerAction("event.unpublish", {
+        description: "Unpublish an event",
+        inputSchema: { eventId: { type: "string", required: true } },
+        async execute(input, ctx) { return req(ctx, "POST", `/events/unpublish/${input.eventId}`); },
+    });
+    rl.registerAction("event.delete", {
+        description: "Delete an event",
+        inputSchema: { eventId: { type: "string", required: true } },
+        async execute(input, ctx) { return req(ctx, "DELETE", `/events/delete/${input.eventId}`); },
+    });
+    // ── Event Tag ───────────────────────────────────────
+    rl.registerAction("eventTag.add", {
+        description: "Add a tag to an event",
+        inputSchema: { eventId: { type: "string", required: true }, tagId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { eventId, tagId } = input;
+            return req(ctx, "POST", "/events/addTag", { event: eventId, tag: tagId });
+        },
+    });
+    rl.registerAction("eventTag.remove", {
+        description: "Remove a tag from an event",
+        inputSchema: { eventId: { type: "string", required: true }, tagId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { eventId, tagId } = input;
+            return req(ctx, "POST", `/events/removeTag/${eventId}/${tagId}`);
+        },
+    });
+    // ── Feed ────────────────────────────────────────────
+    rl.registerAction("feed.create", {
+        description: "Create a feed",
+        inputSchema: {
+            name: { type: "string", required: true },
+            provider: { type: "string", required: true },
+            url: { type: "string", required: true },
+            additionalFields: { type: "object", required: false, description: "input_source, source_format, enabled, distribution, etc." },
+        },
+        async execute(input, ctx) {
+            const { name, provider, url, additionalFields } = input;
+            const body = { name, provider, url };
+            if (additionalFields)
+                Object.assign(body, additionalFields);
+            const data = (await req(ctx, "POST", "/feeds/add", body));
+            return data.Feed;
+        },
+    });
+    rl.registerAction("feed.get", {
+        description: "Get a feed by ID",
+        inputSchema: { feedId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = (await req(ctx, "GET", `/feeds/view/${input.feedId}`));
+            return data.Feed;
+        },
+    });
+    rl.registerAction("feed.list", {
+        description: "List all feeds",
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            let data = (await req(ctx, "GET", "/feeds"));
+            data = data.map((e) => e.Feed);
+            if (input?.limit)
+                data = data.slice(0, input.limit);
+            return data;
+        },
+    });
+    rl.registerAction("feed.update", {
+        description: "Update a feed",
+        inputSchema: { feedId: { type: "string", required: true }, updateFields: { type: "object", required: true } },
+        async execute(input, ctx) {
+            const { feedId, updateFields } = input;
+            const data = (await req(ctx, "PUT", `/feeds/edit/${feedId}`, updateFields));
+            return data.Feed;
+        },
+    });
+    rl.registerAction("feed.enable", {
+        description: "Enable a feed",
+        inputSchema: { feedId: { type: "string", required: true } },
+        async execute(input, ctx) { return req(ctx, "POST", `/feeds/enable/${input.feedId}`); },
+    });
+    rl.registerAction("feed.disable", {
+        description: "Disable a feed",
+        inputSchema: { feedId: { type: "string", required: true } },
+        async execute(input, ctx) { return req(ctx, "POST", `/feeds/disable/${input.feedId}`); },
+    });
+    // ── Galaxy ──────────────────────────────────────────
+    rl.registerAction("galaxy.get", {
+        description: "Get a galaxy by ID",
+        inputSchema: { galaxyId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = (await req(ctx, "GET", `/galaxies/view/${input.galaxyId}`));
+            return data.Galaxy;
+        },
+    });
+    rl.registerAction("galaxy.list", {
+        description: "List all galaxies",
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            let data = (await req(ctx, "GET", "/galaxies"));
+            data = data.map((e) => e.Galaxy);
+            if (input?.limit)
+                data = data.slice(0, input.limit);
+            return data;
+        },
+    });
+    rl.registerAction("galaxy.delete", {
+        description: "Delete a galaxy",
+        inputSchema: { galaxyId: { type: "string", required: true } },
+        async execute(input, ctx) { return req(ctx, "DELETE", `/galaxies/delete/${input.galaxyId}`); },
+    });
+    // ── Noticelist ──────────────────────────────────────
+    rl.registerAction("noticelist.get", {
+        description: "Get a noticelist by ID",
+        inputSchema: { noticelistId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = (await req(ctx, "GET", `/noticelists/view/${input.noticelistId}`));
+            return data.Noticelist;
+        },
+    });
+    rl.registerAction("noticelist.list", {
+        description: "List all noticelists",
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            let data = (await req(ctx, "GET", "/noticelists"));
+            data = data.map((e) => e.Noticelist);
+            if (input?.limit)
+                data = data.slice(0, input.limit);
+            return data;
+        },
+    });
+    // ── Object ──────────────────────────────────────────
+    rl.registerAction("object.search", {
+        description: "Search objects via restSearch",
+        inputSchema: {
+            value: { type: "string", required: false },
+            searchBody: { type: "object", required: false },
+        },
+        async execute(input, ctx) {
+            const { value, searchBody } = (input ?? {});
+            const body = searchBody ?? {};
+            if (value)
+                body.value = value;
+            const data = (await req(ctx, "POST", "/objects/restSearch", body));
+            const response = data.response;
+            return response?.map((o) => o.Object) ?? [];
+        },
+    });
+    // ── Organisation ────────────────────────────────────
+    rl.registerAction("organisation.create", {
+        description: "Create an organisation",
+        inputSchema: {
+            name: { type: "string", required: true },
+            additionalFields: { type: "object", required: false, description: "description, type, nationality, sector, contacts, uuid, local" },
+        },
+        async execute(input, ctx) {
+            const { name, additionalFields } = input;
+            const body = { name };
+            if (additionalFields)
+                Object.assign(body, additionalFields);
+            const data = (await req(ctx, "POST", "/admin/organisations/add", body));
+            return data.Organisation;
+        },
+    });
+    rl.registerAction("organisation.get", {
+        description: "Get an organisation by ID",
+        inputSchema: { organisationId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = (await req(ctx, "GET", `/organisations/view/${input.organisationId}`));
+            return data.Organisation;
+        },
+    });
+    rl.registerAction("organisation.list", {
+        description: "List all organisations",
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            let data = (await req(ctx, "GET", "/organisations"));
+            data = data.map((e) => e.Organisation);
+            if (input?.limit)
+                data = data.slice(0, input.limit);
+            return data;
+        },
+    });
+    rl.registerAction("organisation.update", {
+        description: "Update an organisation",
+        inputSchema: { organisationId: { type: "string", required: true }, updateFields: { type: "object", required: true } },
+        async execute(input, ctx) {
+            const { organisationId, updateFields } = input;
+            const data = (await req(ctx, "PUT", `/admin/organisations/edit/${organisationId}`, updateFields));
+            return data.Organisation;
+        },
+    });
+    rl.registerAction("organisation.delete", {
+        description: "Delete an organisation",
+        inputSchema: { organisationId: { type: "string", required: true } },
+        async execute(input, ctx) { return req(ctx, "DELETE", `/admin/organisations/delete/${input.organisationId}`); },
+    });
+    // ── Tag ─────────────────────────────────────────────
+    rl.registerAction("tag.create", {
+        description: "Create a tag",
+        inputSchema: {
+            name: { type: "string", required: true },
+            colour: { type: "string", required: false, description: "Hex colour (e.g. #ff0000)" },
+        },
+        async execute(input, ctx) {
+            const { name, colour } = input;
+            const body = { name };
+            if (colour)
+                body.colour = colour.startsWith("#") ? colour : `#${colour}`;
+            const data = (await req(ctx, "POST", "/tags/add", body));
+            return data.Tag;
+        },
+    });
+    rl.registerAction("tag.list", {
+        description: "List all tags",
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const data = (await req(ctx, "GET", "/tags"));
+            let tags = data.Tag;
+            if (input?.limit)
+                tags = tags.slice(0, input.limit);
+            return tags;
+        },
+    });
+    rl.registerAction("tag.update", {
+        description: "Update a tag",
+        inputSchema: {
+            tagId: { type: "string", required: true },
+            name: { type: "string", required: false },
+            colour: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const { tagId, name, colour } = input;
+            const body = {};
+            if (name)
+                body.name = name;
+            if (colour)
+                body.colour = colour.startsWith("#") ? colour : `#${colour}`;
+            const data = (await req(ctx, "POST", `/tags/edit/${tagId}`, body));
+            return data.Tag;
+        },
+    });
+    rl.registerAction("tag.delete", {
+        description: "Delete a tag",
+        inputSchema: { tagId: { type: "string", required: true } },
+        async execute(input, ctx) { return req(ctx, "POST", `/tags/delete/${input.tagId}`); },
+    });
+    // ── User ────────────────────────────────────────────
+    rl.registerAction("user.create", {
+        description: "Create a user",
+        inputSchema: {
+            email: { type: "string", required: true },
+            roleId: { type: "string", required: true, description: "Role ID" },
+            additionalFields: { type: "object", required: false, description: "org_id, password, termsaccepted, change_pw, etc." },
+        },
+        async execute(input, ctx) {
+            const { email, roleId, additionalFields } = input;
+            const body = { email, role_id: roleId };
+            if (additionalFields)
+                Object.assign(body, additionalFields);
+            const data = (await req(ctx, "POST", "/admin/users/add", body));
+            return data.User;
+        },
+    });
+    rl.registerAction("user.get", {
+        description: "Get a user by ID",
+        inputSchema: { userId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = (await req(ctx, "GET", `/admin/users/view/${input.userId}`));
+            return data.User;
+        },
+    });
+    rl.registerAction("user.list", {
+        description: "List all users",
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            let data = (await req(ctx, "GET", "/admin/users"));
+            data = data.map((e) => e.User);
+            if (input?.limit)
+                data = data.slice(0, input.limit);
+            return data;
+        },
+    });
+    rl.registerAction("user.update", {
+        description: "Update a user",
+        inputSchema: { userId: { type: "string", required: true }, updateFields: { type: "object", required: true } },
+        async execute(input, ctx) {
+            const { userId, updateFields } = input;
+            const data = (await req(ctx, "PUT", `/admin/users/edit/${userId}`, updateFields));
+            return data.User;
+        },
+    });
+    rl.registerAction("user.delete", {
+        description: "Delete a user",
+        inputSchema: { userId: { type: "string", required: true } },
+        async execute(input, ctx) { return req(ctx, "DELETE", `/admin/users/delete/${input.userId}`); },
+    });
+    // ── Warninglist ─────────────────────────────────────
+    rl.registerAction("warninglist.get", {
+        description: "Get a warninglist by ID",
+        inputSchema: { warninglistId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = (await req(ctx, "GET", `/warninglists/view/${input.warninglistId}`));
+            return data.Warninglist;
+        },
+    });
+    rl.registerAction("warninglist.list", {
+        description: "List all warninglists",
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const data = (await req(ctx, "GET", "/warninglists"));
+            let lists = (data.Warninglists ?? []).map((e) => e.Warninglist);
+            if (input?.limit)
+                lists = lists.slice(0, input.limit);
+            return lists;
+        },
+    });
+}

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

@@ -0,0 +1,67 @@
+const BASE_URL = "https://rest.moceanapi.com";
+async function apiRequest(apiKey, apiSecret, endpoint, body) {
+    body["mocean-api-key"] = apiKey;
+    body["mocean-api-secret"] = apiSecret;
+    body["mocean-resp-format"] = "JSON";
+    const form = new URLSearchParams();
+    for (const [k, v] of Object.entries(body)) {
+        if (v !== undefined && v !== null)
+            form.set(k, String(v));
+    }
+    const res = await fetch(`${BASE_URL}${endpoint}`, {
+        method: "POST",
+        body: form,
+    });
+    if (!res.ok)
+        throw new Error(`Mocean API error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+export default function mocean(rl) {
+    rl.setName("mocean");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: { type: "string", required: true, description: "Mocean API key", env: "MOCEAN_API_KEY" },
+        apiSecret: { type: "string", required: true, description: "Mocean API secret", env: "MOCEAN_API_SECRET" },
+    });
+    const creds = (ctx) => ({
+        apiKey: ctx.connection.config.apiKey,
+        apiSecret: ctx.connection.config.apiSecret,
+    });
+    rl.registerAction("sms.send", {
+        description: "Send an SMS message",
+        inputSchema: {
+            from: { type: "string", required: true, description: "Sender number" },
+            to: { type: "string", required: true, description: "Recipient number" },
+            message: { type: "string", required: true },
+            dlrUrl: { type: "string", required: false, description: "Delivery report URL" },
+        },
+        async execute(input, ctx) {
+            const { from, to, message, dlrUrl } = input;
+            const { apiKey, apiSecret } = creds(ctx);
+            const body = { "mocean-from": from, "mocean-to": to, "mocean-text": message };
+            if (dlrUrl) {
+                body["mocean-dlr-url"] = dlrUrl;
+                body["mocean-dlr-mask"] = "1";
+            }
+            const data = (await apiRequest(apiKey, apiSecret, "/rest/2/sms", body));
+            return data.messages;
+        },
+    });
+    rl.registerAction("voice.send", {
+        description: "Make a voice call with text-to-speech",
+        inputSchema: {
+            from: { type: "string", required: true, description: "Caller number" },
+            to: { type: "string", required: true, description: "Recipient number" },
+            message: { type: "string", required: true, description: "Text to speak" },
+            language: { type: "string", required: false, description: "Language code: en-US (default), en-GB, cmn-CN, ja-JP, ko-KR" },
+        },
+        async execute(input, ctx) {
+            const { from, to, message, language = "en-US" } = input;
+            const { apiKey, apiSecret } = creds(ctx);
+            const command = [{ action: "say", language, text: message }];
+            const body = { "mocean-from": from, "mocean-to": to, "mocean-command": JSON.stringify(command) };
+            const data = (await apiRequest(apiKey, apiSecret, "/rest/2/voice/dial", body));
+            return data.voice;
+        },
+    });
+}