runline 0.1.0

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

@@ -0,0 +1,147 @@
+async function apiRequest(host, apiKey, method, endpoint, body, qs) {
+    const url = new URL(`${host}/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: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey}`,
+        },
+    };
+    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(`Cortex API error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+function getConn(ctx) {
+    return {
+        host: ctx.connection.config.host.replace(/\/$/, ""),
+        apiKey: ctx.connection.config.apiKey,
+    };
+}
+export default function cortex(rl) {
+    rl.setName("cortex");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        host: {
+            type: "string",
+            required: true,
+            description: "Cortex instance URL (e.g. https://cortex.example.com)",
+            env: "CORTEX_HOST",
+        },
+        apiKey: {
+            type: "string",
+            required: true,
+            description: "Cortex API key",
+            env: "CORTEX_API_KEY",
+        },
+    });
+    // ── Analyzer ────────────────────────────────────────
+    rl.registerAction("analyzer.execute", {
+        description: "Run an analyzer on an observable",
+        inputSchema: {
+            analyzerId: { type: "string", required: true, description: "Analyzer ID" },
+            dataType: { type: "string", required: true, description: "Observable type (domain, ip, url, mail, hash, filename, fqdn, uri_path, user-agent, regexp, registry, mail_subject, other)" },
+            data: { type: "string", required: true, description: "Observable value" },
+            tlp: { type: "number", required: false, description: "TLP level: 0=white, 1=green, 2=amber (default), 3=red" },
+            force: { type: "boolean", required: false, description: "Bypass cache" },
+            timeout: { type: "number", required: false, description: "Wait for report (seconds). If set, blocks until report is ready." },
+        },
+        async execute(input, ctx) {
+            const { analyzerId, dataType, data, tlp = 2, force, timeout } = input;
+            const { host, apiKey } = getConn(ctx);
+            const qs = {};
+            if (force)
+                qs.force = true;
+            const result = (await apiRequest(host, apiKey, "POST", `/analyzer/${analyzerId}/run`, {
+                dataType,
+                data,
+                tlp,
+            }, qs));
+            if (timeout && result.id) {
+                return apiRequest(host, apiKey, "GET", `/job/${result.id}/waitreport`, undefined, {
+                    atMost: `${timeout}second`,
+                });
+            }
+            return result;
+        },
+    });
+    // ── Job ─────────────────────────────────────────────
+    rl.registerAction("job.get", {
+        description: "Get job details",
+        inputSchema: {
+            jobId: { type: "string", required: true, description: "Job ID" },
+        },
+        async execute(input, ctx) {
+            const { jobId } = input;
+            const { host, apiKey } = getConn(ctx);
+            return apiRequest(host, apiKey, "GET", `/job/${jobId}`);
+        },
+    });
+    rl.registerAction("job.getReport", {
+        description: "Get job report",
+        inputSchema: {
+            jobId: { type: "string", required: true, description: "Job ID" },
+        },
+        async execute(input, ctx) {
+            const { jobId } = input;
+            const { host, apiKey } = getConn(ctx);
+            return apiRequest(host, apiKey, "GET", `/job/${jobId}/report`);
+        },
+    });
+    // ── Responder ───────────────────────────────────────
+    rl.registerAction("responder.execute", {
+        description: "Run a responder on an entity",
+        inputSchema: {
+            responderId: { type: "string", required: true, description: "Responder ID" },
+            entityType: { type: "string", required: true, description: "Entity type: case, alert, case_artifact, case_task, case_task_log" },
+            data: { type: "object", required: true, description: "Entity data object (must include _type matching entityType)" },
+            tlp: { type: "number", required: false, description: "TLP level (default: 2)" },
+            pap: { type: "number", required: false, description: "PAP level (default: 2)" },
+            message: { type: "string", required: false, description: "Message" },
+        },
+        async execute(input, ctx) {
+            const { responderId, entityType, data, tlp = 2, pap = 2, message } = input;
+            const { host, apiKey } = getConn(ctx);
+            const entityData = { _type: entityType, ...data };
+            const body = {
+                responderId,
+                dataType: `thehive:${entityType}`,
+                data: entityData,
+                tlp,
+                pap,
+                message: message ?? "",
+                parameters: [],
+            };
+            // Generate label based on entity type
+            let label = "";
+            switch (entityType) {
+                case "case":
+                    label = `#${entityData.caseId} ${entityData.title}`;
+                    break;
+                case "alert":
+                    label = `[${entityData.source}:${entityData.sourceRef}] ${entityData.title}`;
+                    break;
+                case "case_artifact":
+                    label = `[${entityData.dataType}] ${entityData.data ?? ""}`;
+                    break;
+                case "case_task":
+                    label = `${entityData.title} (${entityData.status})`;
+                    break;
+                case "case_task_log":
+                    label = `${entityData.message} from ${entityData.createdBy}`;
+                    break;
+            }
+            body.label = label;
+            return apiRequest(host, apiKey, "POST", `/responder/${responderId}/run`, body);
+        },
+    });
+}

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

@@ -0,0 +1,405 @@
+const BASE_URL = "https://api.currents.dev/v1";
+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) {
+                if (Array.isArray(v)) {
+                    for (const item of v)
+                        url.searchParams.append(`${k}[]`, String(item));
+                }
+                else {
+                    url.searchParams.set(k, String(v));
+                }
+            }
+        }
+    }
+    const opts = {
+        method,
+        headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            Authorization: `Bearer ${apiKey}`,
+        },
+    };
+    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(`Currents API error ${res.status}: ${await res.text()}`);
+    if (res.status === 204)
+        return { success: true };
+    return res.json();
+}
+function unwrapData(response) {
+    if (response && typeof response === "object" && "data" in response) {
+        return response.data;
+    }
+    return response;
+}
+function getKey(ctx) {
+    return ctx.connection.config.apiKey;
+}
+export default function currents(rl) {
+    rl.setName("currents");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: {
+            type: "string",
+            required: true,
+            description: "Currents API key",
+            env: "CURRENTS_API_KEY",
+        },
+    });
+    // ── Action ──────────────────────────────────────────
+    rl.registerAction("action.create", {
+        description: "Create a new action (skip, quarantine, or tag rule)",
+        inputSchema: {
+            projectId: { type: "string", required: true, description: "Project ID" },
+            name: { type: "string", required: true, description: "Action name" },
+            actionType: { type: "string", required: true, description: "Type: skip, quarantine, or tag" },
+            matcherType: { type: "string", required: true, description: "Matcher: titleContains, titleEquals, specContains, specEquals, signature" },
+            matcherValue: { type: "string", required: true, description: "Value to match against" },
+            tags: { type: "array", required: false, description: "Tags to apply (for tag action type)" },
+            description: { type: "string", required: false, description: "Description" },
+            expiresAfter: { type: "string", required: false, description: "Expiration date (ISO 8601)" },
+        },
+        async execute(input, ctx) {
+            const { projectId, name, actionType, matcherType, matcherValue, tags, description: desc, expiresAfter } = input;
+            const typeMap = {
+                titleContains: "title", titleEquals: "title",
+                specContains: "file", specEquals: "file",
+                signature: "testId",
+            };
+            const opMap = {
+                titleContains: "inc", titleEquals: "eq",
+                specContains: "inc", specEquals: "eq",
+                signature: "eq",
+            };
+            const action = actionType === "tag" && tags
+                ? [{ op: "tag", details: { tags } }]
+                : [{ op: actionType }];
+            const body = {
+                name,
+                action,
+                matcher: {
+                    op: "AND",
+                    cond: [{ type: typeMap[matcherType], op: opMap[matcherType], value: matcherValue }],
+                },
+            };
+            if (desc)
+                body.description = desc;
+            if (expiresAfter)
+                body.expiresAfter = expiresAfter;
+            return apiRequest(getKey(ctx), "POST", "/actions", body, { projectId });
+        },
+    });
+    rl.registerAction("action.get", {
+        description: "Get an action by ID",
+        inputSchema: { actionId: { type: "string", required: true, description: "Action ID" } },
+        async execute(input, ctx) {
+            return unwrapData(await apiRequest(getKey(ctx), "GET", `/actions/${input.actionId}`));
+        },
+    });
+    rl.registerAction("action.list", {
+        description: "List actions for a project",
+        inputSchema: {
+            projectId: { type: "string", required: true, description: "Project ID" },
+            search: { type: "string", required: false, description: "Search by name" },
+            status: { type: "array", required: false, description: "Filter by status: active, disabled, archived, expired" },
+        },
+        async execute(input, ctx) {
+            const { projectId, search, status } = (input ?? {});
+            const qs = { projectId };
+            if (search)
+                qs.search = search;
+            if (status)
+                qs.status = status;
+            return unwrapData(await apiRequest(getKey(ctx), "GET", "/actions", undefined, qs));
+        },
+    });
+    rl.registerAction("action.update", {
+        description: "Update an action",
+        inputSchema: {
+            actionId: { type: "string", required: true, description: "Action ID" },
+            name: { type: "string", required: false, description: "New name" },
+            description: { type: "string", required: false, description: "New description" },
+            expiresAfter: { type: "string", required: false, description: "Expiration date" },
+        },
+        async execute(input, ctx) {
+            const { actionId, ...body } = input;
+            return apiRequest(getKey(ctx), "PUT", `/actions/${actionId}`, body);
+        },
+    });
+    rl.registerAction("action.enable", {
+        description: "Enable a disabled action",
+        inputSchema: { actionId: { type: "string", required: true, description: "Action ID" } },
+        async execute(input, ctx) {
+            return apiRequest(getKey(ctx), "PUT", `/actions/${input.actionId}/enable`);
+        },
+    });
+    rl.registerAction("action.disable", {
+        description: "Disable an active action",
+        inputSchema: { actionId: { type: "string", required: true, description: "Action ID" } },
+        async execute(input, ctx) {
+            return apiRequest(getKey(ctx), "PUT", `/actions/${input.actionId}/disable`);
+        },
+    });
+    rl.registerAction("action.delete", {
+        description: "Archive (soft delete) an action",
+        inputSchema: { actionId: { type: "string", required: true, description: "Action ID" } },
+        async execute(input, ctx) {
+            await apiRequest(getKey(ctx), "DELETE", `/actions/${input.actionId}`);
+            return { success: true };
+        },
+    });
+    // ── Instance ────────────────────────────────────────
+    rl.registerAction("instance.get", {
+        description: "Get a spec file execution instance with full test results",
+        inputSchema: { instanceId: { type: "string", required: true, description: "Instance ID" } },
+        async execute(input, ctx) {
+            return unwrapData(await apiRequest(getKey(ctx), "GET", `/instances/${input.instanceId}`));
+        },
+    });
+    // ── Project ─────────────────────────────────────────
+    rl.registerAction("project.get", {
+        description: "Get a project by ID",
+        inputSchema: { projectId: { type: "string", required: true, description: "Project ID" } },
+        async execute(input, ctx) {
+            return apiRequest(getKey(ctx), "GET", `/projects/${input.projectId}`);
+        },
+    });
+    rl.registerAction("project.list", {
+        description: "List projects",
+        inputSchema: { limit: { type: "number", required: false, description: "Max results" } },
+        async execute(input, ctx) {
+            const qs = {};
+            const { limit } = (input ?? {});
+            if (limit)
+                qs.limit = limit;
+            return unwrapData(await apiRequest(getKey(ctx), "GET", "/projects", undefined, qs));
+        },
+    });
+    rl.registerAction("project.getInsights", {
+        description: "Get project insights and metrics",
+        inputSchema: {
+            projectId: { type: "string", required: true, description: "Project ID" },
+            dateStart: { type: "string", required: true, description: "Start date (ISO 8601)" },
+            dateEnd: { type: "string", required: true, description: "End date (ISO 8601)" },
+            resolution: { type: "string", required: false, description: "Resolution: 1h, 1d (default), 1w" },
+            branches: { type: "array", required: false, description: "Filter by branches" },
+            authors: { type: "array", required: false, description: "Filter by authors" },
+            tags: { type: "array", required: false, description: "Filter by tags" },
+        },
+        async execute(input, ctx) {
+            const { projectId, dateStart, dateEnd, resolution, branches, authors, tags } = input;
+            const qs = { date_start: dateStart, date_end: dateEnd };
+            if (resolution)
+                qs.resolution = resolution;
+            if (branches)
+                qs.branches = branches;
+            if (authors)
+                qs.authors = authors;
+            if (tags)
+                qs.tags = tags;
+            return unwrapData(await apiRequest(getKey(ctx), "GET", `/projects/${projectId}/insights`, undefined, qs));
+        },
+    });
+    // ── Run ─────────────────────────────────────────────
+    rl.registerAction("run.get", {
+        description: "Get a run by ID",
+        inputSchema: { runId: { type: "string", required: true, description: "Run ID" } },
+        async execute(input, ctx) {
+            return unwrapData(await apiRequest(getKey(ctx), "GET", `/runs/${input.runId}`));
+        },
+    });
+    rl.registerAction("run.list", {
+        description: "List runs for a project",
+        inputSchema: {
+            projectId: { type: "string", required: true, description: "Project ID" },
+            limit: { type: "number", required: false, description: "Max results (default: 10, max: 50)" },
+            search: { type: "string", required: false, description: "Search by ciBuildId or commit message" },
+            status: { type: "array", required: false, description: "Filter by status" },
+            completionState: { type: "array", required: false, description: "Filter by completion state" },
+            branches: { type: "array", required: false, description: "Filter by branches" },
+            authors: { type: "array", required: false, description: "Filter by authors" },
+            tags: { type: "array", required: false, description: "Filter by tags" },
+            dateStart: { type: "string", required: false, description: "Start date" },
+            dateEnd: { type: "string", required: false, description: "End date" },
+        },
+        async execute(input, ctx) {
+            const { projectId, limit, search, status, completionState, branches, authors, tags, dateStart, dateEnd } = (input ?? {});
+            const qs = {};
+            if (limit)
+                qs.limit = limit;
+            if (search)
+                qs.search = search;
+            if (status)
+                qs.status = status;
+            if (completionState)
+                qs.completion_state = completionState;
+            if (branches)
+                qs.branches = branches;
+            if (authors)
+                qs.authors = authors;
+            if (tags)
+                qs.tags = tags;
+            if (dateStart)
+                qs.date_start = dateStart;
+            if (dateEnd)
+                qs.date_end = dateEnd;
+            return unwrapData(await apiRequest(getKey(ctx), "GET", `/projects/${projectId}/runs`, undefined, qs));
+        },
+    });
+    rl.registerAction("run.find", {
+        description: "Find a run by project and filters",
+        inputSchema: {
+            projectId: { type: "string", required: true, description: "Project ID" },
+            branch: { type: "string", required: false, description: "Filter by branch" },
+            ciBuildId: { type: "string", required: false, description: "Filter by CI build ID" },
+            tags: { type: "array", required: false, description: "Filter by tags" },
+        },
+        async execute(input, ctx) {
+            const { projectId, branch, ciBuildId, tags } = (input ?? {});
+            const qs = { projectId };
+            if (branch)
+                qs.branch = branch;
+            if (ciBuildId)
+                qs.ciBuildId = ciBuildId;
+            if (tags)
+                qs.tags = tags;
+            return unwrapData(await apiRequest(getKey(ctx), "GET", "/runs/find", undefined, qs));
+        },
+    });
+    rl.registerAction("run.cancel", {
+        description: "Cancel a run in progress",
+        inputSchema: { runId: { type: "string", required: true, description: "Run ID" } },
+        async execute(input, ctx) {
+            return apiRequest(getKey(ctx), "PUT", `/runs/${input.runId}/cancel`);
+        },
+    });
+    rl.registerAction("run.cancelGithub", {
+        description: "Cancel a run by GitHub Actions workflow run ID",
+        inputSchema: {
+            githubRunId: { type: "string", required: true, description: "GitHub Actions workflow run ID" },
+            githubRunAttempt: { type: "number", required: true, description: "Workflow attempt number" },
+            projectId: { type: "string", required: false, description: "Limit to specific project" },
+            ciBuildId: { type: "string", required: false, description: "Limit to specific CI build" },
+        },
+        async execute(input, ctx) {
+            const body = input;
+            return apiRequest(getKey(ctx), "PUT", "/runs/cancel-ci/github", body);
+        },
+    });
+    rl.registerAction("run.reset", {
+        description: "Reset failed specs for re-execution on specified machines",
+        inputSchema: {
+            runId: { type: "string", required: true, description: "Run ID" },
+            machineIds: { type: "array", required: true, description: "Array of machine identifiers to reset" },
+            isBatchedOr8n: { type: "boolean", required: false, description: "Enable batched orchestration" },
+        },
+        async execute(input, ctx) {
+            const { runId, machineIds, isBatchedOr8n } = input;
+            const body = { machineId: machineIds };
+            if (isBatchedOr8n)
+                body.isBatchedOr8n = true;
+            return apiRequest(getKey(ctx), "PUT", `/runs/${runId}/reset`, body);
+        },
+    });
+    rl.registerAction("run.delete", {
+        description: "Delete a run and all associated data",
+        inputSchema: { runId: { type: "string", required: true, description: "Run ID" } },
+        async execute(input, ctx) {
+            await apiRequest(getKey(ctx), "DELETE", `/runs/${input.runId}`);
+            return { success: true };
+        },
+    });
+    // ── Signature ───────────────────────────────────────
+    rl.registerAction("signature.generate", {
+        description: "Generate a unique test signature",
+        inputSchema: {
+            projectId: { type: "string", required: true, description: "Project ID" },
+            specFilePath: { type: "string", required: true, description: "Full spec file path" },
+            testTitle: { type: "string", required: true, description: "Test title (use ' > ' for nested describes)" },
+        },
+        async execute(input, ctx) {
+            return unwrapData(await apiRequest(getKey(ctx), "POST", "/signature/test", input));
+        },
+    });
+    // ── Spec File ───────────────────────────────────────
+    rl.registerAction("specFile.list", {
+        description: "Get aggregated spec file metrics for a project",
+        inputSchema: {
+            projectId: { type: "string", required: true, description: "Project ID" },
+            dateStart: { type: "string", required: true, description: "Start date (ISO 8601)" },
+            dateEnd: { type: "string", required: true, description: "End date (ISO 8601)" },
+            limit: { type: "number", required: false, description: "Max results (default: 50)" },
+            order: { type: "string", required: false, description: "Order by field" },
+            dir: { type: "string", required: false, description: "Sort direction: asc or desc" },
+        },
+        async execute(input, ctx) {
+            const { projectId, dateStart, dateEnd, limit, order, dir } = input;
+            const qs = { date_start: dateStart, date_end: dateEnd };
+            if (limit)
+                qs.limit = limit;
+            if (order)
+                qs.order = order;
+            if (dir)
+                qs.dir = dir;
+            return unwrapData(await apiRequest(getKey(ctx), "GET", `/spec-files/${projectId}`, undefined, qs));
+        },
+    });
+    // ── Test ────────────────────────────────────────────
+    rl.registerAction("test.list", {
+        description: "Get aggregated test metrics for a project",
+        inputSchema: {
+            projectId: { type: "string", required: true, description: "Project ID" },
+            dateStart: { type: "string", required: true, description: "Start date (ISO 8601)" },
+            dateEnd: { type: "string", required: true, description: "End date (ISO 8601)" },
+            limit: { type: "number", required: false, description: "Max results (default: 50)" },
+            order: { type: "string", required: false, description: "Order by field" },
+            dir: { type: "string", required: false, description: "Sort direction: asc or desc" },
+            title: { type: "string", required: false, description: "Filter by test title" },
+            spec: { type: "string", required: false, description: "Filter by spec file" },
+        },
+        async execute(input, ctx) {
+            const { projectId, dateStart, dateEnd, limit, order, dir, title, spec } = (input ?? {});
+            const qs = { date_start: dateStart, date_end: dateEnd };
+            if (limit)
+                qs.limit = limit;
+            if (order)
+                qs.order = order;
+            if (dir)
+                qs.dir = dir;
+            if (title)
+                qs.title = title;
+            if (spec)
+                qs.spec = spec;
+            return unwrapData(await apiRequest(getKey(ctx), "GET", `/tests/${projectId}`, undefined, qs));
+        },
+    });
+    // ── Test Result ─────────────────────────────────────
+    rl.registerAction("testResult.list", {
+        description: "Get historical test execution results for a test signature",
+        inputSchema: {
+            signature: { type: "string", required: true, description: "Test signature" },
+            dateStart: { type: "string", required: true, description: "Start date (ISO 8601)" },
+            dateEnd: { type: "string", required: true, description: "End date (ISO 8601)" },
+            limit: { type: "number", required: false, description: "Max results (default: 10, max: 100)" },
+            status: { type: "array", required: false, description: "Filter by status: passed, failed, pending, skipped" },
+            branches: { type: "array", required: false, description: "Filter by branches" },
+        },
+        async execute(input, ctx) {
+            const { signature, dateStart, dateEnd, limit, status, branches } = input;
+            const qs = { date_start: dateStart, date_end: dateEnd };
+            if (limit)
+                qs.limit = limit;
+            if (status)
+                qs.status = status;
+            if (branches)
+                qs.branches = branches;
+            return unwrapData(await apiRequest(getKey(ctx), "GET", `/test-results/${signature}`, undefined, qs));
+        },
+    });
+}