runline 0.1.0

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

@@ -0,0 +1,142 @@
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    return { url: c.url.replace(/\/$/, ""), apiKey: c.apiKey };
+}
+async function api(conn, method, endpoint, body, qs) {
+    const url = new URL(`${conn.url}/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: `Bearer ${conn.apiKey}`, "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(`TheHive error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+export default function thehive(rl) {
+    rl.setName("thehive");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        url: { type: "string", required: true, description: "TheHive instance URL", env: "THEHIVE_URL" },
+        apiKey: { type: "string", required: true, description: "TheHive API key", env: "THEHIVE_API_KEY" },
+    });
+    // ── Alert ───────────────────────────────────────────
+    rl.registerAction("alert.create", { description: "Create an alert",
+        inputSchema: { title: { type: "string", required: true }, description: { type: "string", required: true }, severity: { type: "number", required: true, description: "1-4" }, type: { type: "string", required: true }, source: { type: "string", required: true }, sourceRef: { type: "string", required: true }, tlp: { type: "number", required: false }, tags: { type: "string", required: false, description: "Comma-separated" } },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { ...p, date: Date.now() };
+            if (p.tags)
+                body.tags = p.tags.split(",").map(t => t.trim());
+            return api(getConn(ctx), "POST", "/alert", body);
+        } });
+    rl.registerAction("alert.get", { description: "Get an alert by ID", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return api(getConn(ctx), "GET", `/alert/${input.id}`); } });
+    rl.registerAction("alert.list", { description: "List alerts", inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const body = { query: [{ _name: "listAlert" }] };
+            if (p.limit)
+                body.query.push({ _name: "page", from: 0, to: p.limit });
+            return api(getConn(ctx), "POST", "/v1/query", body, { name: "alerts" });
+        } });
+    rl.registerAction("alert.update", { description: "Update an alert", inputSchema: { id: { type: "string", required: true }, data: { type: "object", required: true } },
+        async execute(input, ctx) { const p = input; return api(getConn(ctx), "PATCH", `/alert/${p.id}`, p.data); } });
+    rl.registerAction("alert.markAsRead", { description: "Mark an alert as read", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return api(getConn(ctx), "POST", `/alert/${input.id}/markAsRead`); } });
+    rl.registerAction("alert.markAsUnread", { description: "Mark an alert as unread", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return api(getConn(ctx), "POST", `/alert/${input.id}/markAsUnread`); } });
+    rl.registerAction("alert.promote", { description: "Promote an alert to a case", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return api(getConn(ctx), "POST", `/alert/${input.id}/createCase`); } });
+    rl.registerAction("alert.merge", { description: "Merge an alert into an existing case", inputSchema: { alertId: { type: "string", required: true }, caseId: { type: "string", required: true } },
+        async execute(input, ctx) { const p = input; return api(getConn(ctx), "POST", `/alert/${p.alertId}/merge/${p.caseId}`); } });
+    // ── Case ────────────────────────────────────────────
+    rl.registerAction("case.create", { description: "Create a case",
+        inputSchema: { title: { type: "string", required: true }, description: { type: "string", required: true }, severity: { type: "number", required: true }, tlp: { type: "number", required: false }, tags: { type: "string", required: false, description: "Comma-separated" }, owner: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { ...p, startDate: Date.now() };
+            if (p.tags)
+                body.tags = p.tags.split(",").map(t => t.trim());
+            return api(getConn(ctx), "POST", "/case", body);
+        } });
+    rl.registerAction("case.get", { description: "Get a case", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return api(getConn(ctx), "GET", `/case/${input.id}`); } });
+    rl.registerAction("case.list", { description: "List cases", inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const body = { query: [{ _name: "listCase" }] };
+            if (p.limit)
+                body.query.push({ _name: "page", from: 0, to: p.limit });
+            return api(getConn(ctx), "POST", "/v1/query", body, { name: "cases" });
+        } });
+    rl.registerAction("case.update", { description: "Update a case", inputSchema: { id: { type: "string", required: true }, data: { type: "object", required: true } },
+        async execute(input, ctx) { const p = input; return api(getConn(ctx), "PATCH", `/case/${p.id}`, p.data); } });
+    // ── Observable ──────────────────────────────────────
+    rl.registerAction("observable.create", { description: "Create an observable on a case",
+        inputSchema: { caseId: { type: "string", required: true }, dataType: { type: "string", required: true }, data: { type: "string", required: true }, message: { type: "string", required: false }, tlp: { type: "number", required: false }, ioc: { type: "boolean", required: false }, sighted: { type: "boolean", required: false } },
+        async execute(input, ctx) {
+            const { caseId, ...body } = input;
+            return api(getConn(ctx), "POST", `/case/${caseId}/artifact`, body);
+        } });
+    rl.registerAction("observable.get", { description: "Get an observable", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) {
+            return api(getConn(ctx), "POST", "/v1/query", { query: [{ _name: "getObservable", idOrName: input.id }] }, { name: "get-observable" });
+        } });
+    rl.registerAction("observable.list", { description: "List observables for a case", inputSchema: { caseId: { type: "string", required: true }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { query: [{ _name: "getCase", idOrName: p.caseId }, { _name: "observables" }] };
+            if (p.limit)
+                body.query.push({ _name: "page", from: 0, to: p.limit });
+            return api(getConn(ctx), "POST", "/v1/query", body, { name: "observables" });
+        } });
+    rl.registerAction("observable.update", { description: "Update an observable", inputSchema: { id: { type: "string", required: true }, data: { type: "object", required: true } },
+        async execute(input, ctx) { const p = input; return api(getConn(ctx), "PATCH", `/case/artifact/${p.id}`, p.data); } });
+    // ── Task ────────────────────────────────────────────
+    rl.registerAction("task.create", { description: "Create a task on a case",
+        inputSchema: { caseId: { type: "string", required: true }, title: { type: "string", required: true }, status: { type: "string", required: false, description: "Waiting, InProgress, Completed, Cancel" }, flag: { type: "boolean", required: false } },
+        async execute(input, ctx) {
+            const { caseId, ...body } = input;
+            return api(getConn(ctx), "POST", `/case/${caseId}/task`, body);
+        } });
+    rl.registerAction("task.get", { description: "Get a task", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) {
+            return api(getConn(ctx), "POST", "/v1/query", { query: [{ _name: "getTask", idOrName: input.id }] }, { name: "get-task" });
+        } });
+    rl.registerAction("task.list", { description: "List tasks for a case", inputSchema: { caseId: { type: "string", required: true }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { query: [{ _name: "getCase", idOrName: p.caseId }, { _name: "tasks" }] };
+            if (p.limit)
+                body.query.push({ _name: "page", from: 0, to: p.limit });
+            return api(getConn(ctx), "POST", "/v1/query", body, { name: "case-tasks" });
+        } });
+    rl.registerAction("task.update", { description: "Update a task", inputSchema: { id: { type: "string", required: true }, data: { type: "object", required: true } },
+        async execute(input, ctx) { const p = input; return api(getConn(ctx), "PATCH", `/case/task/${p.id}`, p.data); } });
+    // ── Log ─────────────────────────────────────────────
+    rl.registerAction("log.create", { description: "Create a log entry on a task",
+        inputSchema: { taskId: { type: "string", required: true }, message: { type: "string", required: true }, status: { type: "string", required: false, description: "Ok, Deleted" } },
+        async execute(input, ctx) {
+            const { taskId, ...body } = input;
+            body.startDate = Date.now();
+            return api(getConn(ctx), "POST", `/case/task/${taskId}/log`, body);
+        } });
+    rl.registerAction("log.get", { description: "Get a log entry", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) {
+            return api(getConn(ctx), "POST", "/v1/query", { query: [{ _name: "getLog", idOrName: input.id }] }, { name: "get-log" });
+        } });
+    rl.registerAction("log.list", { description: "List logs for a task", inputSchema: { taskId: { type: "string", required: true }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { query: [{ _name: "getTask", idOrName: p.taskId }, { _name: "logs" }] };
+            if (p.limit)
+                body.query.push({ _name: "page", from: 0, to: p.limit });
+            return api(getConn(ctx), "POST", "/v1/query", body, { name: "case-task-logs" });
+        } });
+}

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

@@ -0,0 +1,194 @@
+function getConn(ctx) {
+    const url = ctx.connection.config.url.replace(/\/$/, "");
+    const apiKey = ctx.connection.config.apiKey;
+    return { url, apiKey };
+}
+async function api(url, apiKey, method, path, body, qs) {
+    const u = new URL(`${url}/api${path}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined)
+                u.searchParams.set(k, String(v));
+        }
+    }
+    const init = { method, headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" } };
+    if (body && Object.keys(body).length > 0)
+        init.body = JSON.stringify(body);
+    const res = await fetch(u.toString(), init);
+    if (res.status === 204)
+        return { success: true };
+    if (!res.ok)
+        throw new Error(`TheHive error ${res.status}: ${await res.text()}`);
+    const text = await res.text();
+    return text ? JSON.parse(text) : { success: true };
+}
+// TheHive v1 query API — paginated search
+async function query(url, apiKey, scope, filters, sortFields, limit) {
+    const q = [];
+    if (scope.id)
+        q.push({ _name: scope.query, idOrName: scope.id });
+    else
+        q.push({ _name: scope.query });
+    if (scope.restrictTo)
+        q.push({ _name: scope.restrictTo });
+    if (filters && filters.length)
+        q.push({ _name: "filter", _and: filters });
+    if (sortFields && sortFields.length)
+        q.push({ _name: "sort", _fields: sortFields });
+    if (limit) {
+        q.push({ _name: "page", from: 0, to: limit });
+        return api(url, apiKey, "POST", "/v1/query", { query: q });
+    }
+    // Paginate in batches of 500
+    const results = [];
+    let from = 0;
+    let batch;
+    do {
+        batch = (await api(url, apiKey, "POST", "/v1/query", { query: [...q, { _name: "page", from, to: from + 500 }] }) ?? []);
+        results.push(...batch);
+        from += 500;
+    } while (batch.length > 0);
+    return results;
+}
+function searchAction(rl, name, scope, description, extraInputs) {
+    rl.registerAction(name, { description,
+        inputSchema: { limit: { type: "number", required: false }, filters: { type: "object", required: false, description: "Array of filter objects" }, sort: { type: "object", required: false, description: "Array of sort field objects" }, ...extraInputs },
+        async execute(input, ctx) {
+            const { url, apiKey } = getConn(ctx);
+            const p = (input ?? {});
+            let s;
+            if (typeof scope === "string") {
+                s = { query: scope };
+            }
+            else {
+                s = scope;
+            }
+            // If there's scope customization via input (e.g. caseId for tasks)
+            if (p.caseId && typeof scope === "object" && scope.restrictTo) {
+                s = { query: "getCase", id: p.caseId, restrictTo: scope.restrictTo };
+            }
+            return query(url, apiKey, s, p.filters, p.sort, p.limit);
+        } });
+}
+export default function theHiveProject(rl) {
+    rl.setName("thehiveProject");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        url: { type: "string", required: true, description: "TheHive instance URL", env: "THEHIVE_URL" },
+        apiKey: { type: "string", required: true, description: "API key", env: "THEHIVE_API_KEY" },
+    });
+    // ── Alert ───────────────────────────────────────────
+    rl.registerAction("alert.create", { description: "Create an alert",
+        inputSchema: { type: { type: "string", required: true }, source: { type: "string", required: true }, sourceRef: { type: "string", required: true }, title: { type: "string", required: true }, description: { type: "string", required: false }, severity: { type: "number", required: false }, tlp: { type: "number", required: false }, tags: { type: "object", required: false }, customFields: { type: "object", required: false } },
+        async execute(input, ctx) { const { url, apiKey } = getConn(ctx); return api(url, apiKey, "POST", "/v1/alert", input); } });
+    rl.registerAction("alert.get", { description: "Get an alert by ID", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { const { url, apiKey } = getConn(ctx); return api(url, apiKey, "GET", `/v1/alert/${input.id}`); } });
+    rl.registerAction("alert.update", { description: "Update an alert by ID",
+        inputSchema: { id: { type: "string", required: true }, title: { type: "string", required: false }, description: { type: "string", required: false }, severity: { type: "number", required: false }, tlp: { type: "number", required: false }, tags: { type: "object", required: false }, status: { type: "string", required: false }, customFields: { type: "object", required: false } },
+        async execute(input, ctx) { const { url, apiKey } = getConn(ctx); const { id, ...body } = input; await api(url, apiKey, "PATCH", `/v1/alert/${id}`, body); return { success: true }; } });
+    rl.registerAction("alert.delete", { description: "Delete an alert", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { const { url, apiKey } = getConn(ctx); await api(url, apiKey, "DELETE", `/v1/alert/${input.id}`); return { success: true }; } });
+    searchAction(rl, "alert.search", "listAlert", "Search alerts");
+    rl.registerAction("alert.merge", { description: "Merge an alert into a case",
+        inputSchema: { alertId: { type: "string", required: true }, caseId: { type: "string", required: true } },
+        async execute(input, ctx) { const { url, apiKey } = getConn(ctx); const p = input; return api(url, apiKey, "POST", `/alert/${p.alertId}/merge/${p.caseId}`); } });
+    rl.registerAction("alert.promote", { description: "Promote an alert to a case",
+        inputSchema: { id: { type: "string", required: true }, caseTemplate: { type: "string", required: false } },
+        async execute(input, ctx) { const { url, apiKey } = getConn(ctx); const p = input; const body = {}; if (p.caseTemplate)
+            body.caseTemplate = p.caseTemplate; return api(url, apiKey, "POST", `/v1/alert/${p.id}/case`, body); } });
+    rl.registerAction("alert.setStatus", { description: "Set alert status",
+        inputSchema: { id: { type: "string", required: true }, status: { type: "string", required: true } },
+        async execute(input, ctx) { const { url, apiKey } = getConn(ctx); const p = input; await api(url, apiKey, "PATCH", `/v1/alert/${p.id}`, { status: p.status }); return { success: true }; } });
+    // ── Case ────────────────────────────────────────────
+    rl.registerAction("case.create", { description: "Create a case",
+        inputSchema: { title: { type: "string", required: true }, description: { type: "string", required: false }, severity: { type: "number", required: false }, tlp: { type: "number", required: false }, tags: { type: "object", required: false }, assignee: { type: "string", required: false }, customFields: { type: "object", required: false } },
+        async execute(input, ctx) { const { url, apiKey } = getConn(ctx); return api(url, apiKey, "POST", "/v1/case", input); } });
+    rl.registerAction("case.get", { description: "Get a case by ID", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { const { url, apiKey } = getConn(ctx); return api(url, apiKey, "POST", "/v1/query", { query: [{ _name: "getCase", idOrName: input.id }, { _name: "page", from: 0, to: 10, extraData: ["attachmentCount"] }] }); } });
+    rl.registerAction("case.update", { description: "Update a case by ID",
+        inputSchema: { id: { type: "string", required: true }, title: { type: "string", required: false }, description: { type: "string", required: false }, severity: { type: "number", required: false }, tlp: { type: "number", required: false }, tags: { type: "object", required: false }, status: { type: "string", required: false }, assignee: { type: "string", required: false }, customFields: { type: "object", required: false } },
+        async execute(input, ctx) { const { url, apiKey } = getConn(ctx); const { id, ...body } = input; await api(url, apiKey, "PATCH", `/v1/case/${id}`, body); return { success: true }; } });
+    rl.registerAction("case.delete", { description: "Delete a case", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { const { url, apiKey } = getConn(ctx); await api(url, apiKey, "DELETE", `/v1/case/${input.id}`); return { success: true }; } });
+    searchAction(rl, "case.search", "listCase", "Search cases");
+    rl.registerAction("case.getTimeline", { description: "Get case timeline", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { const { url, apiKey } = getConn(ctx); return api(url, apiKey, "GET", `/v1/case/${input.id}/timeline`); } });
+    // ── Task ────────────────────────────────────────────
+    rl.registerAction("task.create", { description: "Create a task in a case",
+        inputSchema: { caseId: { type: "string", required: true }, title: { type: "string", required: true }, description: { type: "string", required: false }, status: { type: "string", required: false }, flag: { type: "boolean", required: false }, assignee: { type: "string", required: false } },
+        async execute(input, ctx) { const { url, apiKey } = getConn(ctx); const { caseId, ...body } = input; return api(url, apiKey, "POST", `/v1/case/${caseId}/task`, body); } });
+    rl.registerAction("task.get", { description: "Get a task by ID", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { const { url, apiKey } = getConn(ctx); return api(url, apiKey, "POST", "/v1/query", { query: [{ _name: "getTask", idOrName: input.id }] }); } });
+    rl.registerAction("task.update", { description: "Update a task by ID",
+        inputSchema: { id: { type: "string", required: true }, title: { type: "string", required: false }, description: { type: "string", required: false }, status: { type: "string", required: false }, flag: { type: "boolean", required: false }, assignee: { type: "string", required: false } },
+        async execute(input, ctx) { const { url, apiKey } = getConn(ctx); const { id, ...body } = input; await api(url, apiKey, "PATCH", `/v1/task/${id}`, body); return { success: true }; } });
+    rl.registerAction("task.delete", { description: "Delete a task", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { const { url, apiKey } = getConn(ctx); await api(url, apiKey, "DELETE", `/v1/task/${input.id}`); return { success: true }; } });
+    searchAction(rl, "task.search", "listTask", "Search tasks");
+    // ── Observable ──────────────────────────────────────
+    rl.registerAction("observable.create", { description: "Create an observable in a case or alert",
+        inputSchema: { createIn: { type: "string", required: true, description: "case or alert" }, parentId: { type: "string", required: true, description: "Case or alert ID" }, dataType: { type: "string", required: true }, data: { type: "string", required: false, description: "Value (for non-file types)" }, message: { type: "string", required: false }, tlp: { type: "number", required: false }, tags: { type: "object", required: false }, ioc: { type: "boolean", required: false } },
+        async execute(input, ctx) {
+            const { url, apiKey } = getConn(ctx);
+            const { createIn, parentId, ...body } = input;
+            return api(url, apiKey, "POST", `/v1/${createIn}/${parentId}/observable`, body);
+        } });
+    rl.registerAction("observable.get", { description: "Get an observable by ID", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { const { url, apiKey } = getConn(ctx); return api(url, apiKey, "POST", "/v1/query", { query: [{ _name: "getObservable", idOrName: input.id }] }); } });
+    rl.registerAction("observable.update", { description: "Update an observable by ID",
+        inputSchema: { id: { type: "string", required: true }, message: { type: "string", required: false }, tlp: { type: "number", required: false }, tags: { type: "object", required: false }, ioc: { type: "boolean", required: false }, sighted: { type: "boolean", required: false } },
+        async execute(input, ctx) { const { url, apiKey } = getConn(ctx); const { id, ...body } = input; await api(url, apiKey, "PATCH", `/v1/observable/${id}`, body); return { success: true }; } });
+    rl.registerAction("observable.delete", { description: "Delete an observable", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { const { url, apiKey } = getConn(ctx); await api(url, apiKey, "DELETE", `/v1/observable/${input.id}`); return { success: true }; } });
+    searchAction(rl, "observable.search", "listObservable", "Search observables");
+    // ── Comment ─────────────────────────────────────────
+    rl.registerAction("comment.add", { description: "Add a comment to a case or alert",
+        inputSchema: { addTo: { type: "string", required: true, description: "case or alert" }, parentId: { type: "string", required: true }, message: { type: "string", required: true } },
+        async execute(input, ctx) { const { url, apiKey } = getConn(ctx); const p = input; return api(url, apiKey, "POST", `/v1/${p.addTo}/${p.parentId}/comment`, { message: p.message }); } });
+    rl.registerAction("comment.update", { description: "Update a comment",
+        inputSchema: { id: { type: "string", required: true }, message: { type: "string", required: true } },
+        async execute(input, ctx) { const { url, apiKey } = getConn(ctx); const p = input; return api(url, apiKey, "PATCH", `/v1/comment/${p.id}`, { message: p.message }); } });
+    rl.registerAction("comment.delete", { description: "Delete a comment", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { const { url, apiKey } = getConn(ctx); await api(url, apiKey, "DELETE", `/v1/comment/${input.id}`); return { success: true }; } });
+    searchAction(rl, "comment.search", "listComment", "Search comments");
+    // ── Task Log ────────────────────────────────────────
+    rl.registerAction("log.create", { description: "Create a task log entry",
+        inputSchema: { taskId: { type: "string", required: true }, message: { type: "string", required: true }, startDate: { type: "string", required: false }, includeInTimeline: { type: "string", required: false } },
+        async execute(input, ctx) { const { url, apiKey } = getConn(ctx); const { taskId, ...body } = input; return api(url, apiKey, "POST", `/v1/task/${taskId}/log`, body); } });
+    rl.registerAction("log.get", { description: "Get a log entry by ID", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { const { url, apiKey } = getConn(ctx); return api(url, apiKey, "POST", "/v1/query", { query: [{ _name: "getLog", idOrName: input.id }] }); } });
+    rl.registerAction("log.delete", { description: "Delete a log entry", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { const { url, apiKey } = getConn(ctx); await api(url, apiKey, "DELETE", `/v1/log/${input.id}`); return { success: true }; } });
+    searchAction(rl, "log.search", "listLog", "Search task logs");
+    // ── Page ────────────────────────────────────────────
+    rl.registerAction("page.create", { description: "Create a page (case page or knowledge base)",
+        inputSchema: { caseId: { type: "string", required: false, description: "If omitted, creates in knowledge base" }, title: { type: "string", required: true }, category: { type: "string", required: true }, content: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { url, apiKey } = getConn(ctx);
+            const { caseId, ...body } = input;
+            const endpoint = caseId ? `/v1/case/${caseId}/page` : "/v1/page";
+            return api(url, apiKey, "POST", endpoint, body);
+        } });
+    rl.registerAction("page.update", { description: "Update a page",
+        inputSchema: { pageId: { type: "string", required: true }, caseId: { type: "string", required: false }, content: { type: "string", required: false }, title: { type: "string", required: false }, category: { type: "string", required: false }, order: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const { url, apiKey } = getConn(ctx);
+            const { pageId, caseId, ...body } = input;
+            const endpoint = caseId ? `/v1/case/${caseId}/page/${pageId}` : `/v1/page/${pageId}`;
+            return api(url, apiKey, "PATCH", endpoint, body);
+        } });
+    rl.registerAction("page.delete", { description: "Delete a page",
+        inputSchema: { pageId: { type: "string", required: true }, caseId: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { url, apiKey } = getConn(ctx);
+            const p = input;
+            const endpoint = p.caseId ? `/v1/case/${p.caseId}/page/${p.pageId}` : `/v1/page/${p.pageId}`;
+            await api(url, apiKey, "DELETE", endpoint);
+            return { success: true };
+        } });
+    searchAction(rl, "page.search", "listOrganisationPage", "Search pages");
+    // ── Query ───────────────────────────────────────────
+    rl.registerAction("query.execute", { description: "Execute a raw TheHive Query API request",
+        inputSchema: { query: { type: "object", required: true, description: "Array of query operations" } },
+        async execute(input, ctx) { const { url, apiKey } = getConn(ctx); return api(url, apiKey, "POST", "/v1/query", { query: input.query }); } });
+}

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

@@ -0,0 +1,244 @@
+const BASE = "https://api.todoist.com/rest/v2";
+const SYNC_BASE = "https://api.todoist.com/sync/v9";
+async function api(token, method, endpoint, body, qs) {
+    const url = new URL(`${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 ${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.status === 204)
+        return { success: true };
+    if (!res.ok)
+        throw new Error(`Todoist error ${res.status}: ${await res.text()}`);
+    const text = await res.text();
+    return text ? JSON.parse(text) : { success: true };
+}
+async function syncApi(token, body) {
+    const res = await fetch(`${SYNC_BASE}/sync`, {
+        method: "POST", headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok)
+        throw new Error(`Todoist Sync error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+async function quickAdd(token, body) {
+    const res = await fetch(`${SYNC_BASE}/quick/add`, {
+        method: "POST", headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok)
+        throw new Error(`Todoist error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+export default function todoist(rl) {
+    rl.setName("todoist");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({ apiToken: { type: "string", required: true, description: "Todoist API token", env: "TODOIST_API_TOKEN" } });
+    const t = (ctx) => ctx.connection.config.apiToken;
+    // ── Task ────────────────────────────────────────────
+    rl.registerAction("task.create", { description: "Create a task",
+        inputSchema: { content: { type: "string", required: true }, projectId: { type: "string", required: false }, description: { type: "string", required: false }, priority: { type: "number", required: false, description: "1 (normal) to 4 (urgent)" }, dueString: { type: "string", required: false }, dueDate: { type: "string", required: false, description: "YYYY-MM-DD" }, labels: { type: "object", required: false, description: "Array of label names" }, sectionId: { type: "string", required: false }, parentId: { type: "string", required: false }, assigneeId: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { content: p.content };
+            if (p.projectId)
+                body.project_id = p.projectId;
+            if (p.description)
+                body.description = p.description;
+            if (p.priority)
+                body.priority = p.priority;
+            if (p.dueString)
+                body.due_string = p.dueString;
+            if (p.dueDate)
+                body.due_date = p.dueDate;
+            if (p.labels)
+                body.labels = p.labels;
+            if (p.sectionId)
+                body.section_id = p.sectionId;
+            if (p.parentId)
+                body.parent_id = p.parentId;
+            if (p.assigneeId)
+                body.assignee_id = p.assigneeId;
+            return api(t(ctx), "POST", "/tasks", body);
+        } });
+    rl.registerAction("task.get", { description: "Get a task by ID", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return api(t(ctx), "GET", `/tasks/${input.id}`); } });
+    rl.registerAction("task.list", { description: "List tasks",
+        inputSchema: { projectId: { type: "string", required: false }, sectionId: { type: "string", required: false }, label: { type: "string", required: false }, filter: { type: "string", required: false }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.projectId)
+                qs.project_id = p.projectId;
+            if (p.sectionId)
+                qs.section_id = p.sectionId;
+            if (p.label)
+                qs.label = p.label;
+            if (p.filter)
+                qs.filter = p.filter;
+            const data = (await api(t(ctx), "GET", "/tasks", undefined, qs));
+            return p.limit ? data.slice(0, p.limit) : data;
+        } });
+    rl.registerAction("task.update", { description: "Update a task",
+        inputSchema: { id: { type: "string", required: true }, content: { type: "string", required: false }, description: { type: "string", required: false }, priority: { type: "number", required: false }, dueString: { type: "string", required: false }, dueDate: { type: "string", required: false }, labels: { type: "object", required: false }, assigneeId: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { id, ...fields } = input;
+            const body = {};
+            if (fields.content)
+                body.content = fields.content;
+            if (fields.description)
+                body.description = fields.description;
+            if (fields.priority)
+                body.priority = fields.priority;
+            if (fields.dueString)
+                body.due_string = fields.dueString;
+            if (fields.dueDate)
+                body.due_date = fields.dueDate;
+            if (fields.labels)
+                body.labels = fields.labels;
+            if (fields.assigneeId)
+                body.assignee_id = fields.assigneeId;
+            return api(t(ctx), "POST", `/tasks/${id}`, body);
+        } });
+    rl.registerAction("task.close", { description: "Close (complete) a task", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { await api(t(ctx), "POST", `/tasks/${input.id}/close`); return { success: true }; } });
+    rl.registerAction("task.reopen", { description: "Reopen a task", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { await api(t(ctx), "POST", `/tasks/${input.id}/reopen`); return { success: true }; } });
+    rl.registerAction("task.delete", { description: "Delete a task", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { await api(t(ctx), "DELETE", `/tasks/${input.id}`); return { success: true }; } });
+    rl.registerAction("task.quickAdd", { description: "Quick add a task using natural language",
+        inputSchema: { text: { type: "string", required: true, description: 'e.g. "Buy milk @Grocery #shopping tomorrow"' }, note: { type: "string", required: false }, reminder: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { text: p.text };
+            if (p.note)
+                body.note = p.note;
+            if (p.reminder)
+                body.reminder = p.reminder;
+            return quickAdd(t(ctx), body);
+        } });
+    // ── Project ─────────────────────────────────────────
+    rl.registerAction("project.create", { description: "Create a project",
+        inputSchema: { name: { type: "string", required: true }, color: { type: "string", required: false }, isFavorite: { type: "boolean", required: false }, parentId: { type: "string", required: false }, viewStyle: { type: "string", required: false, description: "list or board" } },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { name: p.name };
+            if (p.color)
+                body.color = p.color;
+            if (p.isFavorite)
+                body.is_favorite = true;
+            if (p.parentId)
+                body.parent_id = p.parentId;
+            if (p.viewStyle)
+                body.view_style = p.viewStyle;
+            return api(t(ctx), "POST", "/projects", body);
+        } });
+    rl.registerAction("project.get", { description: "Get a project", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return api(t(ctx), "GET", `/projects/${input.id}`); } });
+    rl.registerAction("project.list", { description: "List all projects", inputSchema: {},
+        async execute(_input, ctx) { return api(t(ctx), "GET", "/projects"); } });
+    rl.registerAction("project.update", { description: "Update a project",
+        inputSchema: { id: { type: "string", required: true }, name: { type: "string", required: false }, color: { type: "string", required: false }, isFavorite: { type: "boolean", required: false }, viewStyle: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { id, ...fields } = input;
+            const body = {};
+            if (fields.name)
+                body.name = fields.name;
+            if (fields.color)
+                body.color = fields.color;
+            if (fields.isFavorite !== undefined)
+                body.is_favorite = fields.isFavorite;
+            if (fields.viewStyle)
+                body.view_style = fields.viewStyle;
+            return api(t(ctx), "POST", `/projects/${id}`, body);
+        } });
+    rl.registerAction("project.delete", { description: "Delete a project", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { await api(t(ctx), "DELETE", `/projects/${input.id}`); return { success: true }; } });
+    rl.registerAction("project.archive", { description: "Archive a project", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { await api(t(ctx), "POST", `/projects/${input.id}/archive`); return { success: true }; } });
+    rl.registerAction("project.unarchive", { description: "Unarchive a project", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { await api(t(ctx), "POST", `/projects/${input.id}/unarchive`); return { success: true }; } });
+    rl.registerAction("project.getCollaborators", { description: "Get project collaborators", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return api(t(ctx), "GET", `/projects/${input.id}/collaborators`); } });
+    // ── Section ─────────────────────────────────────────
+    rl.registerAction("section.create", { description: "Create a section",
+        inputSchema: { projectId: { type: "string", required: true }, name: { type: "string", required: true }, order: { type: "number", required: false } },
+        async execute(input, ctx) { const p = input; return api(t(ctx), "POST", "/sections", { project_id: p.projectId, name: p.name, ...(p.order ? { order: p.order } : {}) }); } });
+    rl.registerAction("section.get", { description: "Get a section", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return api(t(ctx), "GET", `/sections/${input.id}`); } });
+    rl.registerAction("section.list", { description: "List sections",
+        inputSchema: { projectId: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const qs = {};
+            if (input?.projectId)
+                qs.project_id = input.projectId;
+            return api(t(ctx), "GET", "/sections", undefined, qs);
+        } });
+    rl.registerAction("section.update", { description: "Update a section", inputSchema: { id: { type: "string", required: true }, name: { type: "string", required: true } },
+        async execute(input, ctx) { const p = input; return api(t(ctx), "POST", `/sections/${p.id}`, { name: p.name }); } });
+    rl.registerAction("section.delete", { description: "Delete a section", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { await api(t(ctx), "DELETE", `/sections/${input.id}`); return { success: true }; } });
+    // ── Comment ─────────────────────────────────────────
+    rl.registerAction("comment.create", { description: "Create a comment on a task",
+        inputSchema: { taskId: { type: "string", required: true }, content: { type: "string", required: true } },
+        async execute(input, ctx) { const p = input; return api(t(ctx), "POST", "/comments", { task_id: p.taskId, content: p.content }); } });
+    rl.registerAction("comment.get", { description: "Get a comment", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return api(t(ctx), "GET", `/comments/${input.id}`); } });
+    rl.registerAction("comment.list", { description: "List comments",
+        inputSchema: { taskId: { type: "string", required: false }, projectId: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.taskId)
+                qs.task_id = p.taskId;
+            if (p.projectId)
+                qs.project_id = p.projectId;
+            return api(t(ctx), "GET", "/comments", undefined, qs);
+        } });
+    rl.registerAction("comment.update", { description: "Update a comment", inputSchema: { id: { type: "string", required: true }, content: { type: "string", required: true } },
+        async execute(input, ctx) { const p = input; return api(t(ctx), "POST", `/comments/${p.id}`, { content: p.content }); } });
+    rl.registerAction("comment.delete", { description: "Delete a comment", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { await api(t(ctx), "DELETE", `/comments/${input.id}`); return { success: true }; } });
+    // ── Label ───────────────────────────────────────────
+    rl.registerAction("label.create", { description: "Create a label",
+        inputSchema: { name: { type: "string", required: true }, color: { type: "string", required: false }, order: { type: "number", required: false }, isFavorite: { type: "boolean", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { name: p.name };
+            if (p.color)
+                body.color = p.color;
+            if (p.order)
+                body.order = p.order;
+            if (p.isFavorite)
+                body.is_favorite = true;
+            return api(t(ctx), "POST", "/labels", body);
+        } });
+    rl.registerAction("label.get", { description: "Get a label", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return api(t(ctx), "GET", `/labels/${input.id}`); } });
+    rl.registerAction("label.list", { description: "List all labels", inputSchema: {},
+        async execute(_input, ctx) { return api(t(ctx), "GET", "/labels"); } });
+    rl.registerAction("label.update", { description: "Update a label",
+        inputSchema: { id: { type: "string", required: true }, name: { type: "string", required: false }, color: { type: "string", required: false }, order: { type: "number", required: false }, isFavorite: { type: "boolean", required: false } },
+        async execute(input, ctx) {
+            const { id, ...fields } = input;
+            const body = {};
+            if (fields.name)
+                body.name = fields.name;
+            if (fields.color)
+                body.color = fields.color;
+            if (fields.order)
+                body.order = fields.order;
+            if (fields.isFavorite !== undefined)
+                body.is_favorite = fields.isFavorite;
+            return api(t(ctx), "POST", `/labels/${id}`, body);
+        } });
+    rl.registerAction("label.delete", { description: "Delete a label", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { await api(t(ctx), "DELETE", `/labels/${input.id}`); return { success: true }; } });
+}