runline 0.1.0

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

@@ -0,0 +1,188 @@
+const BASE = "https://api.spotify.com/v1";
+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(`Spotify error ${res.status}: ${await res.text()}`);
+    const text = await res.text();
+    return text ? JSON.parse(text) : { success: true };
+}
+function stripUri(uri, prefix) { return uri.replace(prefix, ""); }
+export default function spotify(rl) {
+    rl.setName("spotify");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({ accessToken: { type: "string", required: true, description: "Spotify OAuth2 access token", env: "SPOTIFY_ACCESS_TOKEN" } });
+    const t = (ctx) => ctx.connection.config.accessToken;
+    // ── Player ──────────────────────────────────────────
+    rl.registerAction("player.pause", { description: "Pause playback", inputSchema: {},
+        async execute(_i, ctx) { return api(t(ctx), "PUT", "/me/player/pause"); } });
+    rl.registerAction("player.resume", { description: "Resume playback", inputSchema: {},
+        async execute(_i, ctx) { return api(t(ctx), "PUT", "/me/player/play"); } });
+    rl.registerAction("player.next", { description: "Skip to next track", inputSchema: {},
+        async execute(_i, ctx) { return api(t(ctx), "POST", "/me/player/next"); } });
+    rl.registerAction("player.previous", { description: "Skip to previous track", inputSchema: {},
+        async execute(_i, ctx) { return api(t(ctx), "POST", "/me/player/previous"); } });
+    rl.registerAction("player.currentlyPlaying", { description: "Get currently playing track", inputSchema: {},
+        async execute(_i, ctx) { return api(t(ctx), "GET", "/me/player/currently-playing"); } });
+    rl.registerAction("player.recentlyPlayed", { description: "Get recently played tracks", inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const qs = {};
+            if (input?.limit)
+                qs.limit = input.limit;
+            const data = (await api(t(ctx), "GET", "/me/player/recently-played", undefined, qs));
+            return data.items;
+        } });
+    rl.registerAction("player.addToQueue", { description: "Add a track to the queue", inputSchema: { uri: { type: "string", required: true, description: "Track URI or ID" } },
+        async execute(input, ctx) { return api(t(ctx), "POST", "/me/player/queue", undefined, { uri: input.uri }); } });
+    rl.registerAction("player.setVolume", { description: "Set playback volume", inputSchema: { volumePercent: { type: "number", required: true, description: "0-100" } },
+        async execute(input, ctx) { return api(t(ctx), "PUT", "/me/player/volume", undefined, { volume_percent: input.volumePercent }); } });
+    rl.registerAction("player.startMusic", { description: "Start playing an album, artist, or playlist", inputSchema: { contextUri: { type: "string", required: true, description: "Spotify URI (e.g. spotify:album:...)" } },
+        async execute(input, ctx) { return api(t(ctx), "PUT", "/me/player/play", { context_uri: input.contextUri }); } });
+    // ── Album ───────────────────────────────────────────
+    rl.registerAction("album.get", { description: "Get an album", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return api(t(ctx), "GET", `/albums/${stripUri(input.id, "spotify:album:")}`); } });
+    rl.registerAction("album.getTracks", { description: "Get an album's tracks", inputSchema: { id: { type: "string", required: true }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const qs = {};
+            if (p.limit)
+                qs.limit = p.limit;
+            const data = (await api(t(ctx), "GET", `/albums/${stripUri(p.id, "spotify:album:")}/tracks`, undefined, qs));
+            return data.items;
+        } });
+    rl.registerAction("album.getNewReleases", { description: "Get new album releases", inputSchema: { limit: { type: "number", required: false }, country: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.limit)
+                qs.limit = p.limit;
+            if (p.country)
+                qs.country = p.country;
+            const data = (await api(t(ctx), "GET", "/browse/new-releases", undefined, qs));
+            return data.albums.items;
+        } });
+    rl.registerAction("album.search", { description: "Search albums", inputSchema: { query: { type: "string", required: true }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const qs = { q: p.query, type: "album" };
+            if (p.limit)
+                qs.limit = p.limit;
+            else
+                qs.limit = 50;
+            const data = (await api(t(ctx), "GET", "/search", undefined, qs));
+            return data.albums.items;
+        } });
+    // ── Artist ──────────────────────────────────────────
+    rl.registerAction("artist.get", { description: "Get an artist", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return api(t(ctx), "GET", `/artists/${stripUri(input.id, "spotify:artist:")}`); } });
+    rl.registerAction("artist.getAlbums", { description: "Get an artist's albums", inputSchema: { id: { type: "string", required: true }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const qs = {};
+            if (p.limit)
+                qs.limit = p.limit;
+            const data = (await api(t(ctx), "GET", `/artists/${stripUri(p.id, "spotify:artist:")}/albums`, undefined, qs));
+            return data.items;
+        } });
+    rl.registerAction("artist.getRelatedArtists", { description: "Get related artists", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = (await api(t(ctx), "GET", `/artists/${stripUri(input.id, "spotify:artist:")}/related-artists`));
+            return data.artists;
+        } });
+    rl.registerAction("artist.getTopTracks", { description: "Get an artist's top tracks", inputSchema: { id: { type: "string", required: true }, country: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            const data = (await api(t(ctx), "GET", `/artists/${stripUri(p.id, "spotify:artist:")}/top-tracks`, undefined, { country: p.country }));
+            return data.tracks;
+        } });
+    rl.registerAction("artist.search", { description: "Search artists", inputSchema: { query: { type: "string", required: true }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const qs = { q: p.query, type: "artist", limit: p.limit ?? 50 };
+            const data = (await api(t(ctx), "GET", "/search", undefined, qs));
+            return data.artists.items;
+        } });
+    // ── Playlist ────────────────────────────────────────
+    rl.registerAction("playlist.get", { description: "Get a playlist", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return api(t(ctx), "GET", `/playlists/${stripUri(input.id, "spotify:playlist:")}`); } });
+    rl.registerAction("playlist.getTracks", { description: "Get a playlist's tracks", inputSchema: { id: { type: "string", required: true }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const qs = {};
+            if (p.limit)
+                qs.limit = p.limit;
+            const data = (await api(t(ctx), "GET", `/playlists/${stripUri(p.id, "spotify:playlist:")}/tracks`, undefined, qs));
+            return data.items;
+        } });
+    rl.registerAction("playlist.create", { description: "Create a playlist", inputSchema: { name: { type: "string", required: true }, description: { type: "string", required: false }, public: { type: "boolean", required: false } },
+        async execute(input, ctx) { return api(t(ctx), "POST", "/me/playlists", input); } });
+    rl.registerAction("playlist.addTrack", { description: "Add a track to a playlist", inputSchema: { id: { type: "string", required: true }, trackUri: { type: "string", required: true }, position: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const qs = { uris: p.trackUri };
+            if (p.position !== undefined)
+                qs.position = p.position;
+            return api(t(ctx), "POST", `/playlists/${stripUri(p.id, "spotify:playlist:")}/tracks`, {}, qs);
+        } });
+    rl.registerAction("playlist.removeTrack", { description: "Remove a track from a playlist", inputSchema: { id: { type: "string", required: true }, trackUri: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return api(t(ctx), "DELETE", `/playlists/${stripUri(p.id, "spotify:playlist:")}/tracks`, { tracks: [{ uri: p.trackUri }] });
+        } });
+    rl.registerAction("playlist.listMine", { description: "Get the current user's playlists", inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const qs = {};
+            if (input?.limit)
+                qs.limit = input.limit;
+            const data = (await api(t(ctx), "GET", "/me/playlists", undefined, qs));
+            return data.items;
+        } });
+    rl.registerAction("playlist.search", { description: "Search playlists", inputSchema: { query: { type: "string", required: true }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const qs = { q: p.query, type: "playlist", limit: p.limit ?? 50 };
+            const data = (await api(t(ctx), "GET", "/search", undefined, qs));
+            return data.playlists.items;
+        } });
+    // ── Track ───────────────────────────────────────────
+    rl.registerAction("track.get", { description: "Get a track", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return api(t(ctx), "GET", `/tracks/${stripUri(input.id, "spotify:track:")}`); } });
+    rl.registerAction("track.getAudioFeatures", { description: "Get audio features for a track", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return api(t(ctx), "GET", `/audio-features/${stripUri(input.id, "spotify:track:")}`); } });
+    rl.registerAction("track.search", { description: "Search tracks", inputSchema: { query: { type: "string", required: true }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const qs = { q: p.query, type: "track", limit: p.limit ?? 50 };
+            const data = (await api(t(ctx), "GET", "/search", undefined, qs));
+            return data.tracks.items;
+        } });
+    // ── Library ─────────────────────────────────────────
+    rl.registerAction("library.getLikedTracks", { description: "Get liked tracks", inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const qs = {};
+            if (input?.limit)
+                qs.limit = input.limit;
+            const data = (await api(t(ctx), "GET", "/me/tracks", undefined, qs));
+            return data.items;
+        } });
+    // ── My Data ─────────────────────────────────────────
+    rl.registerAction("myData.getFollowingArtists", { description: "Get followed artists", inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const qs = { type: "artist" };
+            if (input?.limit)
+                qs.limit = input.limit;
+            const data = (await api(t(ctx), "GET", "/me/following", undefined, qs));
+            return data.artists.items;
+        } });
+}

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

@@ -0,0 +1,82 @@
+const BASE = "https://stackby.com/api/betav1";
+async function apiRequest(apiKey, 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: { "api-key": apiKey, "Content-Type": "application/json" } };
+    if (body !== undefined)
+        init.body = JSON.stringify(body);
+    const res = await fetch(url.toString(), init);
+    if (!res.ok)
+        throw new Error(`Stackby error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+export default function stackby(rl) {
+    rl.setName("stackby");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: { type: "string", required: true, description: "Stackby API key", env: "STACKBY_API_KEY" },
+    });
+    const key = (ctx) => ctx.connection.config.apiKey;
+    rl.registerAction("row.read", {
+        description: "Read a row by ID",
+        inputSchema: {
+            stackId: { type: "string", required: true },
+            table: { type: "string", required: true },
+            rowId: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const data = (await apiRequest(key(ctx), "GET", `/rowlist/${p.stackId}/${encodeURIComponent(p.table)}`, undefined, { rowIds: p.rowId }));
+            return data.map(d => d.field);
+        },
+    });
+    rl.registerAction("row.list", {
+        description: "List rows from a table",
+        inputSchema: {
+            stackId: { type: "string", required: true },
+            table: { type: "string", required: true },
+            view: { type: "string", required: false },
+            limit: { type: "number", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.view)
+                qs.view = p.view;
+            if (p.limit)
+                qs.maxrecord = p.limit;
+            const data = (await apiRequest(key(ctx), "GET", `/rowlist/${p.stackId}/${encodeURIComponent(p.table)}`, undefined, qs));
+            return data.map(d => d.field);
+        },
+    });
+    rl.registerAction("row.append", {
+        description: "Append rows to a table",
+        inputSchema: {
+            stackId: { type: "string", required: true },
+            table: { type: "string", required: true },
+            records: { type: "object", required: true, description: "Array of objects [{field: {col1: val1, col2: val2}}]" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const data = (await apiRequest(key(ctx), "POST", `/rowcreate/${p.stackId}/${encodeURIComponent(p.table)}`, { records: p.records }));
+            return data.map(d => d.field);
+        },
+    });
+    rl.registerAction("row.delete", {
+        description: "Delete a row by ID",
+        inputSchema: {
+            stackId: { type: "string", required: true },
+            table: { type: "string", required: true },
+            rowId: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(key(ctx), "DELETE", `/rowdelete/${p.stackId}/${encodeURIComponent(p.table)}`, undefined, { rowIds: p.rowId });
+        },
+    });
+}

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

@@ -0,0 +1,141 @@
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    return { contentToken: c.contentToken, managementToken: c.managementToken };
+}
+async function contentApi(token, endpoint, qs) {
+    const url = new URL(`https://api.storyblok.com${endpoint}`);
+    url.searchParams.set("token", token);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const res = await fetch(url.toString());
+    if (!res.ok)
+        throw new Error(`Storyblok Content API error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+async function managementApi(token, method, endpoint, body, qs) {
+    const url = new URL(`https://mapi.storyblok.com${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: 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.ok)
+        throw new Error(`Storyblok Management API error ${res.status}: ${await res.text()}`);
+    const text = await res.text();
+    return text ? JSON.parse(text) : {};
+}
+export default function storyblok(rl) {
+    rl.setName("storyblok");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        contentToken: { type: "string", required: false, description: "Storyblok Content Delivery API token (for reading published content)", env: "STORYBLOK_CONTENT_TOKEN" },
+        managementToken: { type: "string", required: false, description: "Storyblok Management API personal access token", env: "STORYBLOK_MANAGEMENT_TOKEN" },
+    });
+    // ── Content API ─────────────────────────────────────
+    rl.registerAction("content.story.get", {
+        description: "Get a published story by slug or ID (Content API)",
+        inputSchema: { identifier: { type: "string", required: true, description: "Story slug or numeric ID" } },
+        async execute(input, ctx) {
+            const conn = getConn(ctx);
+            if (!conn.contentToken)
+                throw new Error("contentToken required for Content API");
+            const data = (await contentApi(conn.contentToken, `/v1/cdn/stories/${input.identifier}`));
+            return data.story;
+        },
+    });
+    rl.registerAction("content.story.list", {
+        description: "List published stories (Content API)",
+        inputSchema: { limit: { type: "number", required: false }, startsWith: { type: "string", required: false, description: "Filter by slug prefix" } },
+        async execute(input, ctx) {
+            const conn = getConn(ctx);
+            if (!conn.contentToken)
+                throw new Error("contentToken required for Content API");
+            const p = (input ?? {});
+            const qs = {};
+            if (p.limit)
+                qs.per_page = p.limit;
+            if (p.startsWith)
+                qs.starts_with = p.startsWith;
+            const data = (await contentApi(conn.contentToken, "/v1/cdn/stories", qs));
+            return data.stories;
+        },
+    });
+    // ── Management API ──────────────────────────────────
+    rl.registerAction("management.story.get", {
+        description: "Get a story by ID (Management API)",
+        inputSchema: { spaceId: { type: "string", required: true }, storyId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const conn = getConn(ctx);
+            if (!conn.managementToken)
+                throw new Error("managementToken required for Management API");
+            const p = input;
+            const data = (await managementApi(conn.managementToken, "GET", `/v1/spaces/${p.spaceId}/stories/${p.storyId}`));
+            return data.story;
+        },
+    });
+    rl.registerAction("management.story.list", {
+        description: "List stories in a space (Management API)",
+        inputSchema: { spaceId: { type: "string", required: true }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const conn = getConn(ctx);
+            if (!conn.managementToken)
+                throw new Error("managementToken required for Management API");
+            const p = (input ?? {});
+            const qs = {};
+            if (p.limit)
+                qs.per_page = p.limit;
+            const data = (await managementApi(conn.managementToken, "GET", `/v1/spaces/${p.spaceId}/stories`, undefined, qs));
+            return data.stories;
+        },
+    });
+    rl.registerAction("management.story.delete", {
+        description: "Delete a story (Management API)",
+        inputSchema: { spaceId: { type: "string", required: true }, storyId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const conn = getConn(ctx);
+            if (!conn.managementToken)
+                throw new Error("managementToken required for Management API");
+            const p = input;
+            const data = (await managementApi(conn.managementToken, "DELETE", `/v1/spaces/${p.spaceId}/stories/${p.storyId}`));
+            return data.story;
+        },
+    });
+    rl.registerAction("management.story.publish", {
+        description: "Publish a story (Management API)",
+        inputSchema: { spaceId: { type: "string", required: true }, storyId: { type: "string", required: true }, releaseId: { type: "string", required: false }, language: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const conn = getConn(ctx);
+            if (!conn.managementToken)
+                throw new Error("managementToken required for Management API");
+            const p = input;
+            const qs = {};
+            if (p.releaseId)
+                qs.release_id = p.releaseId;
+            if (p.language)
+                qs.lang = p.language;
+            const data = (await managementApi(conn.managementToken, "GET", `/v1/spaces/${p.spaceId}/stories/${p.storyId}/publish`, undefined, qs));
+            return data.story;
+        },
+    });
+    rl.registerAction("management.story.unpublish", {
+        description: "Unpublish a story (Management API)",
+        inputSchema: { spaceId: { type: "string", required: true }, storyId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const conn = getConn(ctx);
+            if (!conn.managementToken)
+                throw new Error("managementToken required for Management API");
+            const p = input;
+            const data = (await managementApi(conn.managementToken, "GET", `/v1/spaces/${p.spaceId}/stories/${p.storyId}/unpublish`));
+            return data.story;
+        },
+    });
+}

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

@@ -0,0 +1,152 @@
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    return {
+        url: c.url.replace(/\/$/, ""),
+        apiVersion: c.apiVersion || "v4",
+        apiToken: c.apiToken,
+        email: c.email,
+        password: c.password,
+    };
+}
+let cachedJwt;
+async function getJwt(conn) {
+    if (cachedJwt && cachedJwt.url === conn.url && Date.now() < cachedJwt.expiry)
+        return cachedJwt.token;
+    const authPath = conn.apiVersion === "v4" ? "/api/auth/local" : "/auth/local";
+    const res = await fetch(`${conn.url}${authPath}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ identifier: conn.email, password: conn.password }),
+    });
+    if (!res.ok)
+        throw new Error(`Strapi auth error ${res.status}: ${await res.text()}`);
+    const data = (await res.json());
+    const jwt = data.jwt;
+    cachedJwt = { token: jwt, url: conn.url, expiry: Date.now() + 3600_000 };
+    return jwt;
+}
+async function apiRequest(conn, method, endpoint, body, qs) {
+    let token;
+    if (conn.apiToken) {
+        token = conn.apiToken;
+    }
+    else {
+        token = await getJwt(conn);
+    }
+    const prefix = conn.apiVersion === "v4" ? "/api" : "";
+    const url = new URL(`${conn.url}${prefix}${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.ok)
+        throw new Error(`Strapi error ${res.status}: ${await res.text()}`);
+    const text = await res.text();
+    return text ? JSON.parse(text) : {};
+}
+export default function strapi(rl) {
+    rl.setName("strapi");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        url: { type: "string", required: true, description: "Strapi base URL", env: "STRAPI_URL" },
+        apiVersion: { type: "string", required: false, description: "v3 or v4 (default: v4)", env: "STRAPI_API_VERSION" },
+        apiToken: { type: "string", required: false, description: "Strapi API token (preferred)", env: "STRAPI_API_TOKEN" },
+        email: { type: "string", required: false, description: "Email for password auth", env: "STRAPI_EMAIL" },
+        password: { type: "string", required: false, description: "Password for password auth", env: "STRAPI_PASSWORD" },
+    });
+    rl.registerAction("entry.create", {
+        description: "Create an entry in a content type",
+        inputSchema: {
+            contentType: { type: "string", required: true, description: "Content type plural name (e.g. articles)" },
+            data: { type: "object", required: true, description: "Entry fields" },
+        },
+        async execute(input, ctx) {
+            const conn = getConn(ctx);
+            const p = input;
+            const body = conn.apiVersion === "v4" ? { data: p.data } : p.data;
+            return apiRequest(conn, "POST", `/${p.contentType}`, body);
+        },
+    });
+    rl.registerAction("entry.get", {
+        description: "Get an entry by ID",
+        inputSchema: {
+            contentType: { type: "string", required: true },
+            entryId: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            const conn = getConn(ctx);
+            const p = input;
+            const data = (await apiRequest(conn, "GET", `/${p.contentType}/${p.entryId}`));
+            return conn.apiVersion === "v4" ? data.data : data;
+        },
+    });
+    rl.registerAction("entry.list", {
+        description: "List entries of a content type",
+        inputSchema: {
+            contentType: { type: "string", required: true },
+            limit: { type: "number", required: false },
+            sort: { type: "string", required: false, description: "Comma-separated sort fields" },
+            filters: { type: "string", required: false, description: "JSON filter object" },
+            publicationState: { type: "string", required: false, description: "live or preview" },
+        },
+        async execute(input, ctx) {
+            const conn = getConn(ctx);
+            const p = (input ?? {});
+            const qs = {};
+            if (conn.apiVersion === "v4") {
+                if (p.limit)
+                    qs["pagination[pageSize]"] = p.limit;
+                if (p.sort)
+                    qs.sort = p.sort;
+                if (p.filters)
+                    qs.filters = p.filters;
+                if (p.publicationState)
+                    qs.publicationState = p.publicationState;
+                const data = (await apiRequest(conn, "GET", `/${p.contentType}`, undefined, qs));
+                return data.data;
+            }
+            if (p.limit)
+                qs._limit = p.limit;
+            if (p.sort)
+                qs._sort = p.sort;
+            if (p.filters)
+                qs._where = p.filters;
+            if (p.publicationState)
+                qs._publicationState = p.publicationState;
+            return apiRequest(conn, "GET", `/${p.contentType}`, undefined, qs);
+        },
+    });
+    rl.registerAction("entry.update", {
+        description: "Update an entry by ID",
+        inputSchema: {
+            contentType: { type: "string", required: true },
+            entryId: { type: "string", required: true },
+            data: { type: "object", required: true, description: "Fields to update" },
+        },
+        async execute(input, ctx) {
+            const conn = getConn(ctx);
+            const p = input;
+            const body = conn.apiVersion === "v4" ? { data: p.data } : p.data;
+            const result = (await apiRequest(conn, "PUT", `/${p.contentType}/${p.entryId}`, body));
+            return conn.apiVersion === "v4" ? result.data : result;
+        },
+    });
+    rl.registerAction("entry.delete", {
+        description: "Delete an entry by ID",
+        inputSchema: {
+            contentType: { type: "string", required: true },
+            entryId: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            const conn = getConn(ctx);
+            const p = input;
+            return apiRequest(conn, "DELETE", `/${p.contentType}/${p.entryId}`);
+        },
+    });
+}