runline 0.1.0

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

@@ -0,0 +1,146 @@
+async function apiRequest(domain, apiKey, method, endpoint, body, qs) {
+    const url = new URL(`https://${domain}.freshservice.com/api/v2${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: {
+            Authorization: `Basic ${btoa(`${apiKey}:X`)}`,
+            "Content-Type": "application/json",
+        },
+    };
+    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(`Freshservice API error ${res.status}: ${await res.text()}`);
+    if (res.status === 204)
+        return { success: true };
+    return res.json();
+}
+function getConn(ctx) {
+    return { domain: ctx.connection.config.domain, apiKey: ctx.connection.config.apiKey };
+}
+function req(ctx, method, endpoint, body, qs) {
+    const { domain, apiKey } = getConn(ctx);
+    return apiRequest(domain, apiKey, method, endpoint, body, qs);
+}
+function unwrap(data) {
+    if (data && typeof data === "object" && !Array.isArray(data)) {
+        const keys = Object.keys(data);
+        if (keys.length === 1)
+            return data[keys[0]];
+    }
+    return data;
+}
+function registerCrud(rl, resource, apiPath, singularKey, opts) {
+    rl.registerAction(`${resource}.create`, {
+        description: `Create a ${resource}`,
+        inputSchema: {
+            ...(opts?.extraCreateFields ?? {}),
+            properties: { type: "object", required: true, description: `${resource} properties as key-value pairs` },
+        },
+        async execute(input, ctx) {
+            const { properties, ...rest } = input;
+            const body = { ...properties, ...rest };
+            return unwrap(await req(ctx, "POST", apiPath, body));
+        },
+    });
+    rl.registerAction(`${resource}.get`, {
+        description: `Get a ${resource} by ID`,
+        inputSchema: { id: { type: "number", required: true, description: `${resource} ID` } },
+        async execute(input, ctx) {
+            return unwrap(await req(ctx, "GET", `${apiPath}/${input.id}`));
+        },
+    });
+    rl.registerAction(`${resource}.list`, {
+        description: `List ${resource}s`,
+        inputSchema: {
+            limit: { type: "number", required: false, description: "Max results" },
+            page: { type: "number", required: false, description: "Page number" },
+        },
+        async execute(input, ctx) {
+            const { limit, page } = (input ?? {});
+            const qs = {};
+            if (limit)
+                qs.per_page = limit;
+            if (page)
+                qs.page = page;
+            return unwrap(await req(ctx, "GET", apiPath, undefined, qs));
+        },
+    });
+    rl.registerAction(`${resource}.update`, {
+        description: `Update a ${resource}`,
+        inputSchema: {
+            id: { type: "number", required: true, description: `${resource} ID` },
+            properties: { type: "object", required: true, description: "Fields to update" },
+        },
+        async execute(input, ctx) {
+            const { id, properties } = input;
+            return unwrap(await req(ctx, "PUT", `${apiPath}/${id}`, properties));
+        },
+    });
+    if (!opts?.noDelete) {
+        rl.registerAction(`${resource}.delete`, {
+            description: `Delete a ${resource}`,
+            inputSchema: { id: { type: "number", required: true, description: `${resource} ID` } },
+            async execute(input, ctx) {
+                await req(ctx, "DELETE", `${apiPath}/${input.id}`);
+                return { success: true };
+            },
+        });
+    }
+}
+export default function freshservice(rl) {
+    rl.setName("freshservice");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        domain: { type: "string", required: true, description: "Freshservice subdomain (e.g. 'mycompany')", env: "FRESHSERVICE_DOMAIN" },
+        apiKey: { type: "string", required: true, description: "Freshservice API key", env: "FRESHSERVICE_API_KEY" },
+    });
+    // 16 resources, all CRUD
+    registerCrud(rl, "agent", "/agents", "agent");
+    registerCrud(rl, "agentGroup", "/groups", "group");
+    registerCrud(rl, "announcement", "/announcements", "announcement");
+    registerCrud(rl, "asset", "/assets", "asset");
+    registerCrud(rl, "assetType", "/asset_types", "asset_type");
+    registerCrud(rl, "change", "/changes", "change");
+    registerCrud(rl, "department", "/departments", "department");
+    registerCrud(rl, "location", "/locations", "location");
+    registerCrud(rl, "problem", "/problems", "problem");
+    registerCrud(rl, "product", "/products", "product");
+    registerCrud(rl, "release", "/releases", "release");
+    registerCrud(rl, "requester", "/requesters", "requester");
+    registerCrud(rl, "requesterGroup", "/requester_groups", "requester_group");
+    registerCrud(rl, "software", "/applications", "application");
+    registerCrud(rl, "ticket", "/tickets", "ticket");
+    // agentRole is read-only (get + list only)
+    rl.registerAction("agentRole.get", {
+        description: "Get an agent role by ID",
+        inputSchema: { id: { type: "number", required: true, description: "Role ID" } },
+        async execute(input, ctx) {
+            return unwrap(await req(ctx, "GET", `/roles/${input.id}`));
+        },
+    });
+    rl.registerAction("agentRole.list", {
+        description: "List agent roles",
+        inputSchema: {
+            limit: { type: "number", required: false, description: "Max results" },
+            page: { type: "number", required: false, description: "Page number" },
+        },
+        async execute(input, ctx) {
+            const { limit, page } = (input ?? {});
+            const qs = {};
+            if (limit)
+                qs.per_page = limit;
+            if (page)
+                qs.page = page;
+            return unwrap(await req(ctx, "GET", "/roles", undefined, qs));
+        },
+    });
+}

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

@@ -0,0 +1,149 @@
+async function apiRequest(domain, apiKey, method, endpoint, body, qs) {
+    const url = new URL(`https://${domain}.myfreshworks.com/crm/sales/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: {
+            Authorization: `Token token=${apiKey}`,
+            "Content-Type": "application/json",
+        },
+    };
+    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(`Freshworks CRM API error ${res.status}: ${await res.text()}`);
+    if (res.status === 204)
+        return { success: true };
+    return res.json();
+}
+function getConn(ctx) {
+    return { domain: ctx.connection.config.domain, apiKey: ctx.connection.config.apiKey };
+}
+function req(ctx, method, endpoint, body, qs) {
+    const { domain, apiKey } = getConn(ctx);
+    return apiRequest(domain, apiKey, method, endpoint, body, qs);
+}
+function unwrap(data) {
+    if (data && typeof data === "object" && !Array.isArray(data)) {
+        const keys = Object.keys(data);
+        if (keys.length === 1)
+            return data[keys[0]];
+    }
+    return data;
+}
+function registerCrud(rl, resource, apiPath, wrapKey, opts) {
+    rl.registerAction(`${resource}.create`, {
+        description: `Create a ${resource}`,
+        inputSchema: { properties: { type: "object", required: true, description: `${resource} properties` } },
+        async execute(input, ctx) {
+            const { properties } = input;
+            return unwrap(await req(ctx, "POST", apiPath, { [wrapKey]: properties }));
+        },
+    });
+    if (!opts?.noGet) {
+        rl.registerAction(`${resource}.get`, {
+            description: `Get a ${resource} by ID`,
+            inputSchema: { id: { type: "number", required: true, description: `${resource} ID` } },
+            async execute(input, ctx) {
+                return unwrap(await req(ctx, "GET", `${apiPath}/${input.id}`));
+            },
+        });
+    }
+    if (!opts?.noList) {
+        rl.registerAction(`${resource}.list`, {
+            description: `List ${resource}s`,
+            inputSchema: {
+                limit: { type: "number", required: false, description: "Max results" },
+                page: { type: "number", required: false, description: "Page number" },
+            },
+            async execute(input, ctx) {
+                const { limit, page } = (input ?? {});
+                const qs = {};
+                if (limit)
+                    qs.per_page = limit;
+                if (page)
+                    qs.page = page;
+                return unwrap(await req(ctx, "GET", apiPath, undefined, qs));
+            },
+        });
+    }
+    rl.registerAction(`${resource}.update`, {
+        description: `Update a ${resource}`,
+        inputSchema: {
+            id: { type: "number", required: true, description: `${resource} ID` },
+            properties: { type: "object", required: true, description: "Fields to update" },
+        },
+        async execute(input, ctx) {
+            const { id, properties } = input;
+            return unwrap(await req(ctx, "PUT", `${apiPath}/${id}`, { [wrapKey]: properties }));
+        },
+    });
+    if (!opts?.noDelete) {
+        rl.registerAction(`${resource}.delete`, {
+            description: `Delete a ${resource}`,
+            inputSchema: { id: { type: "number", required: true, description: `${resource} ID` } },
+            async execute(input, ctx) {
+                await req(ctx, "DELETE", `${apiPath}/${input.id}`);
+                return { success: true };
+            },
+        });
+    }
+}
+export default function freshworksCrm(rl) {
+    rl.setName("freshworksCrm");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        domain: { type: "string", required: true, description: "Freshworks CRM subdomain", env: "FRESHWORKS_CRM_DOMAIN" },
+        apiKey: { type: "string", required: true, description: "Freshworks CRM API key", env: "FRESHWORKS_CRM_API_KEY" },
+    });
+    registerCrud(rl, "account", "/sales_accounts", "sales_account");
+    registerCrud(rl, "appointment", "/appointments", "appointment");
+    registerCrud(rl, "contact", "/contacts", "contact");
+    registerCrud(rl, "deal", "/deals", "deal");
+    registerCrud(rl, "note", "/notes", "note", { noGet: true, noList: true });
+    registerCrud(rl, "salesActivity", "/sales_activities", "sales_activity");
+    registerCrud(rl, "task", "/tasks", "task");
+    // ── Search ──────────────────────────────────────────
+    rl.registerAction("search.query", {
+        description: "Search across entities using a query string",
+        inputSchema: {
+            query: { type: "string", required: true, description: "Search query" },
+            entities: { type: "string", required: false, description: "Comma-separated entities to search (contact, deal, sales_account)" },
+            perPage: { type: "number", required: false, description: "Results per page" },
+            page: { type: "number", required: false, description: "Page number" },
+        },
+        async execute(input, ctx) {
+            const { query, entities, perPage, page } = (input ?? {});
+            const qs = { q: query };
+            if (entities)
+                qs.entities = entities;
+            if (perPage)
+                qs.per_page = perPage;
+            if (page)
+                qs.page = page;
+            return req(ctx, "GET", "/search", undefined, qs);
+        },
+    });
+    rl.registerAction("search.lookup", {
+        description: "Lookup a record by field value",
+        inputSchema: {
+            query: { type: "string", required: true, description: "Value to search" },
+            field: { type: "string", required: true, description: "Field to search (e.g. email, name)" },
+            entities: { type: "string", required: false, description: "Entity type to search" },
+        },
+        async execute(input, ctx) {
+            const { query, field, entities } = input;
+            const qs = { q: query, f: field };
+            if (entities)
+                qs.entities = entities;
+            return req(ctx, "GET", "/lookup", undefined, qs);
+        },
+    });
+}

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

@@ -0,0 +1,140 @@
+const BASE_URL = "https://api.getresponse.com/v3";
+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: {
+            "X-Auth-Token": `api-key ${apiKey}`,
+            "Content-Type": "application/json",
+        },
+    };
+    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(`GetResponse API error ${res.status}: ${await res.text()}`);
+    if (res.status === 204 || res.status === 202)
+        return { success: true };
+    return res.json();
+}
+export default function getresponse(rl) {
+    rl.setName("getresponse");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: { type: "string", required: true, description: "GetResponse API key", env: "GETRESPONSE_API_KEY" },
+    });
+    const key = (ctx) => ctx.connection.config.apiKey;
+    rl.registerAction("contact.create", {
+        description: "Create a contact",
+        inputSchema: {
+            email: { type: "string", required: true, description: "Email address" },
+            campaignId: { type: "string", required: true, description: "Campaign ID to subscribe to" },
+            name: { type: "string", required: false, description: "Contact name" },
+            dayOfCycle: { type: "number", required: false, description: "Day of autoresponder cycle" },
+            tags: { type: "array", required: false, description: "Array of {tagId} objects" },
+            customFieldValues: { type: "array", required: false, description: "Custom fields as [{customFieldId, value: [values]}]" },
+        },
+        async execute(input, ctx) {
+            const { email, campaignId, name, dayOfCycle, tags, customFieldValues } = input;
+            const body = { email, campaign: { campaignId } };
+            if (name)
+                body.name = name;
+            if (dayOfCycle !== undefined)
+                body.dayOfCycle = dayOfCycle;
+            if (tags)
+                body.tags = tags;
+            if (customFieldValues)
+                body.customFieldValues = customFieldValues;
+            await apiRequest(key(ctx), "POST", "/contacts", body);
+            return { success: true };
+        },
+    });
+    rl.registerAction("contact.get", {
+        description: "Get a contact by ID",
+        inputSchema: {
+            contactId: { type: "string", required: true, description: "Contact ID" },
+            fields: { type: "string", required: false, description: "Comma-separated fields to return" },
+        },
+        async execute(input, ctx) {
+            const { contactId, fields } = (input ?? {});
+            const qs = {};
+            if (fields)
+                qs.fields = fields;
+            return apiRequest(key(ctx), "GET", `/contacts/${contactId}`, undefined, qs);
+        },
+    });
+    rl.registerAction("contact.list", {
+        description: "List contacts",
+        inputSchema: {
+            limit: { type: "number", required: false, description: "Max results (default: 100)" },
+            email: { type: "string", required: false, description: "Filter by email" },
+            name: { type: "string", required: false, description: "Filter by name" },
+            campaignId: { type: "string", required: false, description: "Filter by campaign ID" },
+            sortBy: { type: "string", required: false, description: "Sort field: email, name, createdOn" },
+            sortOrder: { type: "string", required: false, description: "ASC or DESC" },
+        },
+        async execute(input, ctx) {
+            const { limit, email, name, campaignId, sortBy, sortOrder } = (input ?? {});
+            const qs = {};
+            if (limit)
+                qs.perPage = limit;
+            if (email)
+                qs["query[email]"] = email;
+            if (name)
+                qs["query[name]"] = name;
+            if (campaignId)
+                qs["query[campaignId]"] = campaignId;
+            if (sortBy)
+                qs[`sort[${sortBy}]`] = sortOrder ?? "ASC";
+            return apiRequest(key(ctx), "GET", "/contacts", undefined, qs);
+        },
+    });
+    rl.registerAction("contact.update", {
+        description: "Update a contact",
+        inputSchema: {
+            contactId: { type: "string", required: true, description: "Contact ID" },
+            name: { type: "string", required: false, description: "New name" },
+            campaignId: { type: "string", required: false, description: "Move to campaign" },
+            tags: { type: "array", required: false, description: "Tags as [{tagId}]" },
+            customFieldValues: { type: "array", required: false, description: "Custom fields as [{customFieldId, value: [values]}]" },
+        },
+        async execute(input, ctx) {
+            const { contactId, name, campaignId, tags, customFieldValues } = input;
+            const body = {};
+            if (name)
+                body.name = name;
+            if (campaignId)
+                body.campaign = { campaignId };
+            if (tags)
+                body.tags = tags;
+            if (customFieldValues)
+                body.customFieldValues = customFieldValues;
+            return apiRequest(key(ctx), "POST", `/contacts/${contactId}`, body);
+        },
+    });
+    rl.registerAction("contact.delete", {
+        description: "Delete a contact",
+        inputSchema: {
+            contactId: { type: "string", required: true, description: "Contact ID" },
+            messageId: { type: "string", required: false, description: "ID of removal confirmation message" },
+            ipAddress: { type: "string", required: false, description: "IP address for GDPR consent" },
+        },
+        async execute(input, ctx) {
+            const { contactId, messageId, ipAddress } = (input ?? {});
+            const qs = {};
+            if (messageId)
+                qs.messageId = messageId;
+            if (ipAddress)
+                qs.ipAddress = ipAddress;
+            await apiRequest(key(ctx), "DELETE", `/contacts/${contactId}`, undefined, qs);
+            return { success: true };
+        },
+    });
+}

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

@@ -0,0 +1,192 @@
+async function apiRequest(url, adminApiKey, method, endpoint, body, qs) {
+    // Ghost Admin API uses JWT. Key format: {id}:{secret}
+    const [id, secret] = adminApiKey.split(":");
+    // Create JWT manually using HMAC-SHA256
+    const header = btoa(JSON.stringify({ alg: "HS256", typ: "JWT", kid: id })).replace(/=/g, "");
+    const now = Math.floor(Date.now() / 1000);
+    const payload = btoa(JSON.stringify({ iat: now, exp: now + 300, aud: "/admin/" })).replace(/=/g, "");
+    const enc = new TextEncoder();
+    const keyData = new Uint8Array((secret.match(/.{2}/g) ?? []).map((b) => parseInt(b, 16)));
+    const cryptoKey = await crypto.subtle.importKey("raw", keyData, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+    const sig = await crypto.subtle.sign("HMAC", cryptoKey, enc.encode(`${header}.${payload}`));
+    const sigStr = btoa(String.fromCharCode(...new Uint8Array(sig)))
+        .replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+    const token = `${header}.${payload}.${sigStr}`;
+    const base = url.replace(/\/$/, "");
+    const fullUrl = new URL(`${base}/ghost/api/v2/admin${endpoint}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                fullUrl.searchParams.set(k, String(v));
+        }
+    }
+    const opts = {
+        method,
+        headers: { Authorization: `Ghost ${token}`, "Content-Type": "application/json" },
+    };
+    if (body && Object.keys(body).length > 0 && method !== "GET" && method !== "DELETE") {
+        opts.body = JSON.stringify(body);
+    }
+    const res = await fetch(fullUrl.toString(), opts);
+    if (!res.ok)
+        throw new Error(`Ghost API error ${res.status}: ${await res.text()}`);
+    if (res.status === 204)
+        return { success: true };
+    return res.json();
+}
+function getConn(ctx) {
+    return {
+        url: ctx.connection.config.url.replace(/\/$/, ""),
+        adminApiKey: ctx.connection.config.adminApiKey,
+    };
+}
+function req(ctx, method, endpoint, body, qs) {
+    const { url, adminApiKey } = getConn(ctx);
+    return apiRequest(url, adminApiKey, method, endpoint, body, qs);
+}
+export default function ghost(rl) {
+    rl.setName("ghost");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        url: { type: "string", required: true, description: "Ghost site URL (e.g. https://myblog.com)", env: "GHOST_URL" },
+        adminApiKey: { type: "string", required: true, description: "Admin API key (format: {id}:{secret})", env: "GHOST_ADMIN_API_KEY" },
+    });
+    rl.registerAction("post.create", {
+        description: "Create a post",
+        inputSchema: {
+            title: { type: "string", required: true, description: "Post title" },
+            html: { type: "string", required: false, description: "Post content as HTML" },
+            lexical: { type: "string", required: false, description: "Post content as Lexical JSON" },
+            status: { type: "string", required: false, description: "draft (default), published, or scheduled" },
+            publishedAt: { type: "string", required: false, description: "Publish date (ISO 8601, required for scheduled)" },
+            tags: { type: "array", required: false, description: "Array of tag names or {name} objects" },
+            authors: { type: "array", required: false, description: "Array of {id} objects" },
+            featured: { type: "boolean", required: false, description: "Mark as featured" },
+            slug: { type: "string", required: false, description: "Custom slug" },
+        },
+        async execute(input, ctx) {
+            const { title, html, lexical, status, publishedAt, tags, authors, featured, slug } = input;
+            const post = { title };
+            const qs = {};
+            if (html) {
+                post.html = html;
+                qs.source = "html";
+            }
+            if (lexical)
+                post.lexical = lexical;
+            if (status)
+                post.status = status;
+            if (publishedAt)
+                post.published_at = publishedAt;
+            if (tags)
+                post.tags = tags.map((t) => typeof t === "string" ? { name: t } : t);
+            if (authors)
+                post.authors = authors;
+            if (featured !== undefined)
+                post.featured = featured;
+            if (slug)
+                post.slug = slug;
+            const data = (await req(ctx, "POST", "/posts/", { posts: [post] }, qs));
+            return data.posts?.[0];
+        },
+    });
+    rl.registerAction("post.get", {
+        description: "Get a post by ID or slug",
+        inputSchema: {
+            id: { type: "string", required: false, description: "Post ID" },
+            slug: { type: "string", required: false, description: "Post slug" },
+            formats: { type: "string", required: false, description: "Response formats: html, mobiledoc, lexical" },
+        },
+        async execute(input, ctx) {
+            const { id, slug, formats } = (input ?? {});
+            const qs = {};
+            if (formats)
+                qs.formats = formats;
+            let endpoint;
+            if (slug)
+                endpoint = `/posts/slug/${slug}/`;
+            else if (id)
+                endpoint = `/posts/${id}/`;
+            else
+                throw new Error("Provide either id or slug");
+            const data = (await req(ctx, "GET", endpoint, undefined, qs));
+            return data.posts?.[0];
+        },
+    });
+    rl.registerAction("post.list", {
+        description: "List posts",
+        inputSchema: {
+            limit: { type: "number", required: false, description: "Max results (default: 15)" },
+            page: { type: "number", required: false, description: "Page number" },
+            filter: { type: "string", required: false, description: "Ghost filter string (e.g. 'tag:news')" },
+            formats: { type: "string", required: false, description: "Response formats" },
+            order: { type: "string", required: false, description: "Order (e.g. 'published_at desc')" },
+        },
+        async execute(input, ctx) {
+            const { limit, page, filter, formats, order } = (input ?? {});
+            const qs = {};
+            if (limit)
+                qs.limit = limit;
+            if (page)
+                qs.page = page;
+            if (filter)
+                qs.filter = filter;
+            if (formats)
+                qs.formats = formats;
+            if (order)
+                qs.order = order;
+            const data = (await req(ctx, "GET", "/posts/", undefined, qs));
+            return data.posts;
+        },
+    });
+    rl.registerAction("post.update", {
+        description: "Update a post",
+        inputSchema: {
+            postId: { type: "string", required: true, description: "Post ID" },
+            title: { type: "string", required: false, description: "New title" },
+            html: { type: "string", required: false, description: "New HTML content" },
+            lexical: { type: "string", required: false, description: "New Lexical JSON content" },
+            status: { type: "string", required: false, description: "New status" },
+            publishedAt: { type: "string", required: false, description: "New publish date" },
+            tags: { type: "array", required: false, description: "New tags" },
+            featured: { type: "boolean", required: false, description: "Featured flag" },
+            slug: { type: "string", required: false, description: "New slug" },
+        },
+        async execute(input, ctx) {
+            const { postId, title, html, lexical, status, publishedAt, tags, featured, slug } = input;
+            // Need updated_at for optimistic locking
+            const existing = (await req(ctx, "GET", `/posts/${postId}/`, undefined, { fields: "id,updated_at" }));
+            const currentPost = existing.posts[0];
+            const post = { updated_at: currentPost.updated_at };
+            const qs = {};
+            if (title)
+                post.title = title;
+            if (html) {
+                post.html = html;
+                qs.source = "html";
+            }
+            if (lexical)
+                post.lexical = lexical;
+            if (status)
+                post.status = status;
+            if (publishedAt)
+                post.published_at = publishedAt;
+            if (tags)
+                post.tags = tags.map((t) => typeof t === "string" ? { name: t } : t);
+            if (featured !== undefined)
+                post.featured = featured;
+            if (slug)
+                post.slug = slug;
+            const data = (await req(ctx, "PUT", `/posts/${postId}/`, { posts: [post] }, qs));
+            return data.posts?.[0];
+        },
+    });
+    rl.registerAction("post.delete", {
+        description: "Delete a post",
+        inputSchema: { postId: { type: "string", required: true, description: "Post ID" } },
+        async execute(input, ctx) {
+            await req(ctx, "DELETE", `/posts/${input.postId}/`);
+            return { success: true };
+        },
+    });
+}