runline 0.1.0

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

@@ -0,0 +1,443 @@
+const BASE_URL = "https://api.clockify.me/api/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)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const opts = {
+        method,
+        headers: { "Content-Type": "application/json", "X-Api-Key": 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) {
+        const text = await res.text();
+        throw new Error(`Clockify API error ${res.status}: ${text}`);
+    }
+    if (res.status === 204)
+        return { success: true };
+    const ct = res.headers.get("content-type") ?? "";
+    if (ct.includes("application/json"))
+        return res.json();
+    return { success: true };
+}
+async function paginateAll(apiKey, endpoint, qs, limit) {
+    const results = [];
+    let page = 1;
+    const size = 50;
+    while (true) {
+        const data = (await apiRequest(apiKey, "GET", endpoint, undefined, { ...qs, page, "page-size": size }));
+        if (!Array.isArray(data))
+            break;
+        results.push(...data);
+        if (limit && results.length >= limit)
+            return results.slice(0, limit);
+        if (data.length < size)
+            break;
+        page++;
+    }
+    return results;
+}
+function getKey(ctx) {
+    return ctx.connection.config.apiKey;
+}
+export default function clockify(rl) {
+    rl.setName("clockify");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: {
+            type: "string",
+            required: true,
+            description: "Clockify API key",
+            env: "CLOCKIFY_API_KEY",
+        },
+    });
+    // ── Client ──────────────────────────────────────────
+    rl.registerAction("client.create", {
+        description: "Create a client",
+        inputSchema: {
+            workspaceId: { type: "string", required: true, description: "Workspace ID" },
+            name: { type: "string", required: true, description: "Client name" },
+        },
+        async execute(input, ctx) {
+            const { workspaceId, name } = input;
+            return apiRequest(getKey(ctx), "POST", `workspaces/${workspaceId}/clients`, { name });
+        },
+    });
+    rl.registerAction("client.get", {
+        description: "Get a client",
+        inputSchema: {
+            workspaceId: { type: "string", required: true, description: "Workspace ID" },
+            clientId: { type: "string", required: true, description: "Client ID" },
+        },
+        async execute(input, ctx) {
+            const { workspaceId, clientId } = input;
+            return apiRequest(getKey(ctx), "GET", `workspaces/${workspaceId}/clients/${clientId}`);
+        },
+    });
+    rl.registerAction("client.list", {
+        description: "List clients in a workspace",
+        inputSchema: {
+            workspaceId: { type: "string", required: true, description: "Workspace ID" },
+            name: { type: "string", required: false, description: "Filter by name" },
+            archived: { type: "boolean", required: false, description: "Include archived" },
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { workspaceId, name, archived, limit } = (input ?? {});
+            const qs = {};
+            if (name)
+                qs.name = name;
+            if (archived !== undefined)
+                qs.archived = archived;
+            return paginateAll(getKey(ctx), `workspaces/${workspaceId}/clients`, qs, limit);
+        },
+    });
+    rl.registerAction("client.update", {
+        description: "Update a client",
+        inputSchema: {
+            workspaceId: { type: "string", required: true, description: "Workspace ID" },
+            clientId: { type: "string", required: true, description: "Client ID" },
+            name: { type: "string", required: true, description: "Client name" },
+            archived: { type: "boolean", required: false, description: "Archived" },
+        },
+        async execute(input, ctx) {
+            const { workspaceId, clientId, ...body } = input;
+            return apiRequest(getKey(ctx), "PUT", `workspaces/${workspaceId}/clients/${clientId}`, body);
+        },
+    });
+    rl.registerAction("client.delete", {
+        description: "Delete a client",
+        inputSchema: {
+            workspaceId: { type: "string", required: true, description: "Workspace ID" },
+            clientId: { type: "string", required: true, description: "Client ID" },
+        },
+        async execute(input, ctx) {
+            const { workspaceId, clientId } = input;
+            await apiRequest(getKey(ctx), "DELETE", `workspaces/${workspaceId}/clients/${clientId}`);
+            return { success: true };
+        },
+    });
+    // ── Project ─────────────────────────────────────────
+    rl.registerAction("project.create", {
+        description: "Create a project",
+        inputSchema: {
+            workspaceId: { type: "string", required: true, description: "Workspace ID" },
+            name: { type: "string", required: true, description: "Project name" },
+            clientId: { type: "string", required: false, description: "Client ID" },
+            isPublic: { type: "boolean", required: false, description: "Public project" },
+            billable: { type: "boolean", required: false, description: "Billable" },
+            color: { type: "string", required: false, description: "Color hex" },
+            note: { type: "string", required: false, description: "Note" },
+        },
+        async execute(input, ctx) {
+            const { workspaceId, ...body } = input;
+            return apiRequest(getKey(ctx), "POST", `workspaces/${workspaceId}/projects`, body);
+        },
+    });
+    rl.registerAction("project.get", {
+        description: "Get a project",
+        inputSchema: {
+            workspaceId: { type: "string", required: true, description: "Workspace ID" },
+            projectId: { type: "string", required: true, description: "Project ID" },
+        },
+        async execute(input, ctx) {
+            const { workspaceId, projectId } = input;
+            return apiRequest(getKey(ctx), "GET", `workspaces/${workspaceId}/projects/${projectId}`);
+        },
+    });
+    rl.registerAction("project.list", {
+        description: "List projects in a workspace",
+        inputSchema: {
+            workspaceId: { type: "string", required: true, description: "Workspace ID" },
+            name: { type: "string", required: false, description: "Filter by name" },
+            archived: { type: "boolean", required: false, description: "Include archived" },
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { workspaceId, name, archived, limit } = (input ?? {});
+            const qs = {};
+            if (name)
+                qs.name = name;
+            if (archived !== undefined)
+                qs.archived = archived;
+            return paginateAll(getKey(ctx), `workspaces/${workspaceId}/projects`, qs, limit);
+        },
+    });
+    rl.registerAction("project.update", {
+        description: "Update a project",
+        inputSchema: {
+            workspaceId: { type: "string", required: true, description: "Workspace ID" },
+            projectId: { type: "string", required: true, description: "Project ID" },
+            name: { type: "string", required: false, description: "Name" },
+            clientId: { type: "string", required: false, description: "Client ID" },
+            isPublic: { type: "boolean", required: false, description: "Public" },
+            billable: { type: "boolean", required: false, description: "Billable" },
+            color: { type: "string", required: false, description: "Color" },
+            note: { type: "string", required: false, description: "Note" },
+            archived: { type: "boolean", required: false, description: "Archived" },
+        },
+        async execute(input, ctx) {
+            const { workspaceId, projectId, ...body } = input;
+            return apiRequest(getKey(ctx), "PUT", `workspaces/${workspaceId}/projects/${projectId}`, body);
+        },
+    });
+    rl.registerAction("project.delete", {
+        description: "Delete a project",
+        inputSchema: {
+            workspaceId: { type: "string", required: true, description: "Workspace ID" },
+            projectId: { type: "string", required: true, description: "Project ID" },
+        },
+        async execute(input, ctx) {
+            const { workspaceId, projectId } = input;
+            await apiRequest(getKey(ctx), "DELETE", `workspaces/${workspaceId}/projects/${projectId}`);
+            return { success: true };
+        },
+    });
+    // ── Tag ─────────────────────────────────────────────
+    rl.registerAction("tag.create", {
+        description: "Create a tag",
+        inputSchema: {
+            workspaceId: { type: "string", required: true, description: "Workspace ID" },
+            name: { type: "string", required: true, description: "Tag name" },
+        },
+        async execute(input, ctx) {
+            const { workspaceId, name } = input;
+            return apiRequest(getKey(ctx), "POST", `workspaces/${workspaceId}/tags`, { name });
+        },
+    });
+    rl.registerAction("tag.list", {
+        description: "List tags in a workspace",
+        inputSchema: {
+            workspaceId: { type: "string", required: true, description: "Workspace ID" },
+            name: { type: "string", required: false, description: "Filter by name" },
+            archived: { type: "boolean", required: false, description: "Include archived" },
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { workspaceId, name, archived, limit } = (input ?? {});
+            const qs = {};
+            if (name)
+                qs.name = name;
+            if (archived !== undefined)
+                qs.archived = archived;
+            return paginateAll(getKey(ctx), `workspaces/${workspaceId}/tags`, qs, limit);
+        },
+    });
+    rl.registerAction("tag.update", {
+        description: "Update a tag",
+        inputSchema: {
+            workspaceId: { type: "string", required: true, description: "Workspace ID" },
+            tagId: { type: "string", required: true, description: "Tag ID" },
+            name: { type: "string", required: false, description: "Name" },
+            archived: { type: "boolean", required: false, description: "Archived" },
+        },
+        async execute(input, ctx) {
+            const { workspaceId, tagId, ...body } = input;
+            return apiRequest(getKey(ctx), "PUT", `workspaces/${workspaceId}/tags/${tagId}`, body);
+        },
+    });
+    rl.registerAction("tag.delete", {
+        description: "Delete a tag",
+        inputSchema: {
+            workspaceId: { type: "string", required: true, description: "Workspace ID" },
+            tagId: { type: "string", required: true, description: "Tag ID" },
+        },
+        async execute(input, ctx) {
+            const { workspaceId, tagId } = input;
+            await apiRequest(getKey(ctx), "DELETE", `workspaces/${workspaceId}/tags/${tagId}`);
+            return { success: true };
+        },
+    });
+    // ── Task ────────────────────────────────────────────
+    rl.registerAction("task.create", {
+        description: "Create a task in a project",
+        inputSchema: {
+            workspaceId: { type: "string", required: true, description: "Workspace ID" },
+            projectId: { type: "string", required: true, description: "Project ID" },
+            name: { type: "string", required: true, description: "Task name" },
+            assigneeIds: { type: "array", required: false, description: "Assignee user IDs" },
+            estimate: { type: "string", required: false, description: "Estimate (HH:MM format)" },
+            status: { type: "string", required: false, description: "Status: ACTIVE or DONE" },
+        },
+        async execute(input, ctx) {
+            const { workspaceId, projectId, estimate, ...body } = input;
+            if (estimate) {
+                const [h, m] = estimate.split(":");
+                body.estimate = `PT${h}H${m}M`;
+            }
+            return apiRequest(getKey(ctx), "POST", `workspaces/${workspaceId}/projects/${projectId}/tasks`, body);
+        },
+    });
+    rl.registerAction("task.get", {
+        description: "Get a task",
+        inputSchema: {
+            workspaceId: { type: "string", required: true, description: "Workspace ID" },
+            projectId: { type: "string", required: true, description: "Project ID" },
+            taskId: { type: "string", required: true, description: "Task ID" },
+        },
+        async execute(input, ctx) {
+            const { workspaceId, projectId, taskId } = input;
+            return apiRequest(getKey(ctx), "GET", `workspaces/${workspaceId}/projects/${projectId}/tasks/${taskId}`);
+        },
+    });
+    rl.registerAction("task.list", {
+        description: "List tasks in a project",
+        inputSchema: {
+            workspaceId: { type: "string", required: true, description: "Workspace ID" },
+            projectId: { type: "string", required: true, description: "Project ID" },
+            isActive: { type: "boolean", required: false, description: "Filter active tasks" },
+            name: { type: "string", required: false, description: "Filter by name" },
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { workspaceId, projectId, isActive, name, limit } = (input ?? {});
+            const qs = {};
+            if (isActive !== undefined)
+                qs["is-active"] = isActive;
+            if (name)
+                qs.name = name;
+            if (limit) {
+                qs["page-size"] = limit;
+                return apiRequest(getKey(ctx), "GET", `workspaces/${workspaceId}/projects/${projectId}/tasks`, undefined, qs);
+            }
+            return paginateAll(getKey(ctx), `workspaces/${workspaceId}/projects/${projectId}/tasks`, qs);
+        },
+    });
+    rl.registerAction("task.update", {
+        description: "Update a task",
+        inputSchema: {
+            workspaceId: { type: "string", required: true, description: "Workspace ID" },
+            projectId: { type: "string", required: true, description: "Project ID" },
+            taskId: { type: "string", required: true, description: "Task ID" },
+            name: { type: "string", required: false, description: "Name" },
+            assigneeIds: { type: "array", required: false, description: "Assignee IDs" },
+            estimate: { type: "string", required: false, description: "Estimate (HH:MM)" },
+            status: { type: "string", required: false, description: "Status" },
+        },
+        async execute(input, ctx) {
+            const { workspaceId, projectId, taskId, estimate, ...body } = input;
+            if (estimate) {
+                const [h, m] = estimate.split(":");
+                body.estimate = `PT${h}H${m}M`;
+            }
+            return apiRequest(getKey(ctx), "PUT", `workspaces/${workspaceId}/projects/${projectId}/tasks/${taskId}`, body);
+        },
+    });
+    rl.registerAction("task.delete", {
+        description: "Delete a task",
+        inputSchema: {
+            workspaceId: { type: "string", required: true, description: "Workspace ID" },
+            projectId: { type: "string", required: true, description: "Project ID" },
+            taskId: { type: "string", required: true, description: "Task ID" },
+        },
+        async execute(input, ctx) {
+            const { workspaceId, projectId, taskId } = input;
+            await apiRequest(getKey(ctx), "DELETE", `workspaces/${workspaceId}/projects/${projectId}/tasks/${taskId}`);
+            return { success: true };
+        },
+    });
+    // ── Time Entry ──────────────────────────────────────
+    rl.registerAction("timeEntry.create", {
+        description: "Create a time entry",
+        inputSchema: {
+            workspaceId: { type: "string", required: true, description: "Workspace ID" },
+            start: { type: "string", required: true, description: "Start time (ISO 8601)" },
+            end: { type: "string", required: false, description: "End time (ISO 8601)" },
+            description: { type: "string", required: false, description: "Description" },
+            projectId: { type: "string", required: false, description: "Project ID" },
+            taskId: { type: "string", required: false, description: "Task ID" },
+            tagIds: { type: "array", required: false, description: "Tag IDs" },
+            billable: { type: "boolean", required: false, description: "Billable" },
+        },
+        async execute(input, ctx) {
+            const { workspaceId, ...body } = input;
+            return apiRequest(getKey(ctx), "POST", `workspaces/${workspaceId}/time-entries`, body);
+        },
+    });
+    rl.registerAction("timeEntry.get", {
+        description: "Get a time entry",
+        inputSchema: {
+            workspaceId: { type: "string", required: true, description: "Workspace ID" },
+            timeEntryId: { type: "string", required: true, description: "Time entry ID" },
+        },
+        async execute(input, ctx) {
+            const { workspaceId, timeEntryId } = input;
+            return apiRequest(getKey(ctx), "GET", `workspaces/${workspaceId}/time-entries/${timeEntryId}`);
+        },
+    });
+    rl.registerAction("timeEntry.update", {
+        description: "Update a time entry",
+        inputSchema: {
+            workspaceId: { type: "string", required: true, description: "Workspace ID" },
+            timeEntryId: { type: "string", required: true, description: "Time entry ID" },
+            start: { type: "string", required: false, description: "Start time" },
+            end: { type: "string", required: false, description: "End time" },
+            description: { type: "string", required: false, description: "Description" },
+            projectId: { type: "string", required: false, description: "Project ID" },
+            taskId: { type: "string", required: false, description: "Task ID" },
+            tagIds: { type: "array", required: false, description: "Tag IDs" },
+            billable: { type: "boolean", required: false, description: "Billable" },
+        },
+        async execute(input, ctx) {
+            const { workspaceId, timeEntryId, ...body } = input;
+            // start is required by API — fetch current if not set
+            if (!body.start) {
+                const current = (await apiRequest(getKey(ctx), "GET", `workspaces/${workspaceId}/time-entries/${timeEntryId}`));
+                const interval = current.timeInterval;
+                body.start = interval.start;
+            }
+            return apiRequest(getKey(ctx), "PUT", `workspaces/${workspaceId}/time-entries/${timeEntryId}`, body);
+        },
+    });
+    rl.registerAction("timeEntry.delete", {
+        description: "Delete a time entry",
+        inputSchema: {
+            workspaceId: { type: "string", required: true, description: "Workspace ID" },
+            timeEntryId: { type: "string", required: true, description: "Time entry ID" },
+        },
+        async execute(input, ctx) {
+            const { workspaceId, timeEntryId } = input;
+            await apiRequest(getKey(ctx), "DELETE", `workspaces/${workspaceId}/time-entries/${timeEntryId}`);
+            return { success: true };
+        },
+    });
+    // ── User ────────────────────────────────────────────
+    rl.registerAction("user.list", {
+        description: "List users in a workspace",
+        inputSchema: {
+            workspaceId: { type: "string", required: true, description: "Workspace ID" },
+            email: { type: "string", required: false, description: "Filter by email" },
+            status: { type: "string", required: false, description: "Filter by status: ACTIVE, PENDING, DECLINED" },
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { workspaceId, email, status, limit } = (input ?? {});
+            const qs = {};
+            if (email)
+                qs.email = email;
+            if (status)
+                qs.status = status;
+            return paginateAll(getKey(ctx), `workspaces/${workspaceId}/users`, qs, limit);
+        },
+    });
+    // ── Workspace ───────────────────────────────────────
+    rl.registerAction("workspace.list", {
+        description: "List all workspaces",
+        inputSchema: {
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { limit } = (input ?? {});
+            const data = (await apiRequest(getKey(ctx), "GET", "workspaces"));
+            if (limit)
+                return data.slice(0, limit);
+            return data;
+        },
+    });
+}

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

@@ -0,0 +1,93 @@
+const BASE_URL = "https://api.cloudflare.com/client/v4";
+async function apiRequest(token, method, endpoint, body, qs) {
+    const url = new URL(`${BASE_URL}${endpoint}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const opts = {
+        method,
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
+    };
+    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) {
+        const text = await res.text();
+        throw new Error(`Cloudflare API error ${res.status}: ${text}`);
+    }
+    return res.json();
+}
+function getToken(ctx) {
+    return ctx.connection.config.apiToken;
+}
+export default function cloudflare(rl) {
+    rl.setName("cloudflare");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiToken: {
+            type: "string",
+            required: true,
+            description: "Cloudflare API token",
+            env: "CLOUDFLARE_API_TOKEN",
+        },
+    });
+    rl.registerAction("zoneCertificate.get", {
+        description: "Get a zone-level origin certificate",
+        inputSchema: {
+            zoneId: { type: "string", required: true, description: "Zone ID" },
+            certificateId: { type: "string", required: true, description: "Certificate ID" },
+        },
+        async execute(input, ctx) {
+            const { zoneId, certificateId } = input;
+            const data = (await apiRequest(getToken(ctx), "GET", `/zones/${zoneId}/origin_tls_client_auth/${certificateId}`));
+            return data.result;
+        },
+    });
+    rl.registerAction("zoneCertificate.list", {
+        description: "List zone-level origin certificates",
+        inputSchema: {
+            zoneId: { type: "string", required: true, description: "Zone ID" },
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { zoneId, limit } = input;
+            const qs = {};
+            if (limit)
+                qs.per_page = limit;
+            const data = (await apiRequest(getToken(ctx), "GET", `/zones/${zoneId}/origin_tls_client_auth`, undefined, qs));
+            return data.result;
+        },
+    });
+    rl.registerAction("zoneCertificate.upload", {
+        description: "Upload a zone-level origin certificate",
+        inputSchema: {
+            zoneId: { type: "string", required: true, description: "Zone ID" },
+            certificate: { type: "string", required: true, description: "PEM certificate" },
+            privateKey: { type: "string", required: true, description: "PEM private key" },
+        },
+        async execute(input, ctx) {
+            const { zoneId, certificate, privateKey } = input;
+            const data = (await apiRequest(getToken(ctx), "POST", `/zones/${zoneId}/origin_tls_client_auth`, {
+                certificate,
+                private_key: privateKey,
+            }));
+            return data.result;
+        },
+    });
+    rl.registerAction("zoneCertificate.delete", {
+        description: "Delete a zone-level origin certificate",
+        inputSchema: {
+            zoneId: { type: "string", required: true, description: "Zone ID" },
+            certificateId: { type: "string", required: true, description: "Certificate ID" },
+        },
+        async execute(input, ctx) {
+            const { zoneId, certificateId } = input;
+            const data = (await apiRequest(getToken(ctx), "DELETE", `/zones/${zoneId}/origin_tls_client_auth/${certificateId}`));
+            return data.result;
+        },
+    });
+}

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

@@ -0,0 +1,131 @@
+async function apiRequest(baseUrl, token, method, endpoint, body) {
+    const url = new URL(`${baseUrl}/api${endpoint}`);
+    url.searchParams.set("token", token);
+    const opts = {
+        method,
+        headers: { "Content-Type": "application/json", Accept: "application/json" },
+    };
+    if (body && Object.keys(body).length > 0 && method !== "GET") {
+        opts.body = JSON.stringify(body);
+    }
+    const res = await fetch(url.toString(), opts);
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Cockpit API error ${res.status}: ${text}`);
+    }
+    return res.json();
+}
+function getConn(ctx) {
+    return {
+        baseUrl: ctx.connection.config.url.replace(/\/$/, ""),
+        token: ctx.connection.config.accessToken,
+    };
+}
+export default function cockpit(rl) {
+    rl.setName("cockpit");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        url: {
+            type: "string",
+            required: true,
+            description: "Cockpit CMS URL (e.g. https://cockpit.example.com)",
+            env: "COCKPIT_URL",
+        },
+        accessToken: {
+            type: "string",
+            required: true,
+            description: "Cockpit API token",
+            env: "COCKPIT_ACCESS_TOKEN",
+        },
+    });
+    // ── Collection ──────────────────────────────────────
+    rl.registerAction("collection.create", {
+        description: "Create an entry in a collection",
+        inputSchema: {
+            collection: { type: "string", required: true, description: "Collection name" },
+            data: { type: "object", required: true, description: "Entry data as key-value pairs" },
+        },
+        async execute(input, ctx) {
+            const { collection, data } = input;
+            const { baseUrl, token } = getConn(ctx);
+            return apiRequest(baseUrl, token, "POST", `/collections/save/${collection}`, { data });
+        },
+    });
+    rl.registerAction("collection.list", {
+        description: "List entries in a collection",
+        inputSchema: {
+            collection: { type: "string", required: true, description: "Collection name" },
+            filter: { type: "object", required: false, description: "Filter object" },
+            fields: { type: "array", required: false, description: "Array of field names to return" },
+            sort: { type: "object", required: false, description: "Sort object (e.g. {fieldName: 1})" },
+            limit: { type: "number", required: false, description: "Max results" },
+            skip: { type: "number", required: false, description: "Number to skip" },
+            populate: { type: "boolean", required: false, description: "Populate linked entries" },
+            language: { type: "string", required: false, description: "Language code" },
+        },
+        async execute(input, ctx) {
+            const { collection, filter, fields, sort, limit, skip, populate, language } = (input ?? {});
+            const { baseUrl, token } = getConn(ctx);
+            const body = { simple: true };
+            if (filter)
+                body.filter = filter;
+            if (fields) {
+                const f = { _id: false };
+                for (const name of fields)
+                    f[name] = true;
+                body.fields = f;
+            }
+            if (sort)
+                body.sort = sort;
+            if (limit)
+                body.limit = limit;
+            if (skip)
+                body.skip = skip;
+            if (populate)
+                body.populate = populate;
+            if (language)
+                body.lang = language;
+            return apiRequest(baseUrl, token, "POST", `/collections/get/${collection}`, body);
+        },
+    });
+    rl.registerAction("collection.update", {
+        description: "Update an entry in a collection",
+        inputSchema: {
+            collection: { type: "string", required: true, description: "Collection name" },
+            id: { type: "string", required: true, description: "Entry _id" },
+            data: { type: "object", required: true, description: "Fields to update" },
+        },
+        async execute(input, ctx) {
+            const { collection, id, data } = input;
+            const { baseUrl, token } = getConn(ctx);
+            return apiRequest(baseUrl, token, "POST", `/collections/save/${collection}`, {
+                data: { _id: id, ...data },
+            });
+        },
+    });
+    // ── Form ────────────────────────────────────────────
+    rl.registerAction("form.submit", {
+        description: "Submit a form",
+        inputSchema: {
+            form: { type: "string", required: true, description: "Form name" },
+            data: { type: "object", required: true, description: "Form data as key-value pairs" },
+        },
+        async execute(input, ctx) {
+            const { form, data } = input;
+            const { baseUrl, token } = getConn(ctx);
+            return apiRequest(baseUrl, token, "POST", `/forms/submit/${form}`, { form: data });
+        },
+    });
+    // ── Singleton ───────────────────────────────────────
+    rl.registerAction("singleton.get", {
+        description: "Get a singleton's data",
+        inputSchema: {
+            singleton: { type: "string", required: true, description: "Singleton name" },
+        },
+        async execute(input, ctx) {
+            const { singleton } = input;
+            const { baseUrl, token } = getConn(ctx);
+            return apiRequest(baseUrl, token, "GET", `/singletons/get/${singleton}`);
+        },
+    });
+}