runline 0.2.1 → 0.2.2

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

@@ -7,7 +7,13 @@ async function api(token, method, endpoint, body, qs) {
                 url.searchParams.set(k, String(v));
         }
     }
-    const init = { method, headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" } };
+    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);
@@ -18,41 +24,119 @@ async function api(token, method, endpoint, body, qs) {
     const text = await res.text();
     return text ? JSON.parse(text) : { success: true };
 }
-function stripUri(uri, prefix) { return uri.replace(prefix, ""); }
+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" } });
+    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 } },
+    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 }); } });
+        },
+    });
+    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 } },
+    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 = {};
@@ -60,8 +144,14 @@ export default function spotify(rl) {
                 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 } },
+        },
+    });
+    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 = {};
@@ -71,8 +161,14 @@ export default function spotify(rl) {
                 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 } },
+        },
+    });
+    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" };
@@ -82,11 +178,22 @@ export default function spotify(rl) {
                 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 } },
+    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 = {};
@@ -94,29 +201,59 @@ export default function spotify(rl) {
                 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 } },
+        },
+    });
+    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 } },
+        },
+    });
+    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 } },
+        },
+    });
+    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 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 } },
+    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 = {};
@@ -124,65 +261,127 @@ export default function spotify(rl) {
                 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 } },
+        },
+    });
+    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 } },
+        },
+    });
+    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 } },
+        },
+    });
+    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 } },
+        },
+    });
+    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 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 } },
+    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 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 } },
+    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 } },
+    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

@@ -7,7 +7,10 @@ async function apiRequest(apiKey, method, endpoint, body, qs) {
                 url.searchParams.set(k, String(v));
         }
     }
-    const init = { method, headers: { "api-key": apiKey, "Content-Type": "application/json" } };
+    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);
@@ -19,7 +22,12 @@ 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" },
+        apiKey: {
+            type: "string",
+            required: true,
+            description: "Stackby API key",
+            env: "STACKBY_API_KEY",
+        },
     });
     const key = (ctx) => ctx.connection.config.apiKey;
     rl.registerAction("row.read", {
@@ -32,7 +40,7 @@ export default function stackby(rl) {
         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);
+            return data.map((d) => d.field);
         },
     });
     rl.registerAction("row.list", {
@@ -51,7 +59,7 @@ export default function stackby(rl) {
             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);
+            return data.map((d) => d.field);
         },
     });
     rl.registerAction("row.append", {
@@ -59,12 +67,16 @@ export default function stackby(rl) {
         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}}]" },
+            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);
+            return data.map((d) => d.field);
         },
     });
     rl.registerAction("row.delete", {

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

@@ -1,6 +1,9 @@
 function getConn(ctx) {
     const c = ctx.connection.config;
-    return { contentToken: c.contentToken, managementToken: c.managementToken };
+    return {
+        contentToken: c.contentToken,
+        managementToken: c.managementToken,
+    };
 }
 async function contentApi(token, endpoint, qs) {
     const url = new URL(`https://api.storyblok.com${endpoint}`);
@@ -24,7 +27,10 @@ async function managementApi(token, method, endpoint, body, qs) {
                 url.searchParams.set(k, String(v));
         }
     }
-    const init = { method, headers: { Authorization: token, "Content-Type": "application/json" } };
+    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);
@@ -37,13 +43,29 @@ 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" },
+        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" } },
+        inputSchema: {
+            identifier: {
+                type: "string",
+                required: true,
+                description: "Story slug or numeric ID",
+            },
+        },
         async execute(input, ctx) {
             const conn = getConn(ctx);
             if (!conn.contentToken)
@@ -54,7 +76,14 @@ export default function storyblok(rl) {
     });
     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" } },
+        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)
@@ -72,7 +101,10 @@ export default function storyblok(rl) {
     // ── 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 } },
+        inputSchema: {
+            spaceId: { type: "string", required: true },
+            storyId: { type: "string", required: true },
+        },
         async execute(input, ctx) {
             const conn = getConn(ctx);
             if (!conn.managementToken)
@@ -84,7 +116,10 @@ export default function storyblok(rl) {
     });
     rl.registerAction("management.story.list", {
         description: "List stories in a space (Management API)",
-        inputSchema: { spaceId: { type: "string", required: true }, limit: { type: "number", required: false } },
+        inputSchema: {
+            spaceId: { type: "string", required: true },
+            limit: { type: "number", required: false },
+        },
         async execute(input, ctx) {
             const conn = getConn(ctx);
             if (!conn.managementToken)
@@ -99,7 +134,10 @@ export default function storyblok(rl) {
     });
     rl.registerAction("management.story.delete", {
         description: "Delete a story (Management API)",
-        inputSchema: { spaceId: { type: "string", required: true }, storyId: { type: "string", required: true } },
+        inputSchema: {
+            spaceId: { type: "string", required: true },
+            storyId: { type: "string", required: true },
+        },
         async execute(input, ctx) {
             const conn = getConn(ctx);
             if (!conn.managementToken)
@@ -111,7 +149,12 @@ export default function storyblok(rl) {
     });
     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 } },
+        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)
@@ -128,7 +171,10 @@ export default function storyblok(rl) {
     });
     rl.registerAction("management.story.unpublish", {
         description: "Unpublish a story (Management API)",
-        inputSchema: { spaceId: { type: "string", required: true }, storyId: { type: "string", required: true } },
+        inputSchema: {
+            spaceId: { type: "string", required: true },
+            storyId: { type: "string", required: true },
+        },
         async execute(input, ctx) {
             const conn = getConn(ctx);
             if (!conn.managementToken)