runline 0.1.0

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

@@ -0,0 +1,383 @@
+let cachedToken = null;
+async function getAccessToken(clientId, clientSecret, tokenUrl) {
+    if (cachedToken && Date.now() < cachedToken.expiresAt)
+        return cachedToken.value;
+    const res = await fetch(tokenUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({
+            client_id: clientId,
+            client_secret: clientSecret,
+            grant_type: "client_credentials",
+            scope: "api.organization",
+            deviceName: "runline",
+            deviceType: "2",
+            deviceIdentifier: "runline",
+        }),
+    });
+    if (!res.ok)
+        throw new Error(`Bitwarden token error ${res.status}: ${await res.text()}`);
+    const data = (await res.json());
+    cachedToken = { value: data.access_token, expiresAt: Date.now() + (data.expires_in - 60) * 1000 };
+    return cachedToken.value;
+}
+async function apiRequest(token, baseUrl, method, endpoint, body, qs) {
+    const url = new URL(`${baseUrl}${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(`Bitwarden API error ${res.status}: ${text}`);
+    }
+    if (res.status === 204 || res.headers.get("content-length") === "0")
+        return { success: true };
+    const ct = res.headers.get("content-type") ?? "";
+    if (ct.includes("application/json"))
+        return res.json();
+    return { success: true };
+}
+function getConn(ctx) {
+    const cfg = ctx.connection.config;
+    const domain = cfg.domain?.replace(/\/$/, "");
+    const env = cfg.environment;
+    const baseUrl = env === "selfHosted" && domain ? `${domain}/api` : "https://api.bitwarden.com";
+    const tokenUrl = env === "selfHosted" && domain
+        ? `${domain}/identity/connect/token`
+        : "https://identity.bitwarden.com/connect/token";
+    return {
+        clientId: cfg.clientId,
+        clientSecret: cfg.clientSecret,
+        baseUrl,
+        tokenUrl,
+    };
+}
+async function authedRequest(ctx, method, endpoint, body, qs) {
+    const { clientId, clientSecret, baseUrl, tokenUrl } = getConn(ctx);
+    const token = await getAccessToken(clientId, clientSecret, tokenUrl);
+    return apiRequest(token, baseUrl, method, endpoint, body, qs);
+}
+export default function bitwarden(rl) {
+    rl.setName("bitwarden");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        clientId: {
+            type: "string",
+            required: true,
+            description: "Bitwarden API client ID",
+            env: "BITWARDEN_CLIENT_ID",
+        },
+        clientSecret: {
+            type: "string",
+            required: true,
+            description: "Bitwarden API client secret",
+            env: "BITWARDEN_CLIENT_SECRET",
+        },
+        environment: {
+            type: "string",
+            required: false,
+            description: "cloudHosted (default) or selfHosted",
+            env: "BITWARDEN_ENVIRONMENT",
+            default: "cloudHosted",
+        },
+        domain: {
+            type: "string",
+            required: false,
+            description: "Self-hosted domain URL (only if environment=selfHosted)",
+            env: "BITWARDEN_DOMAIN",
+        },
+    });
+    // ── Collection ──────────────────────────────────────
+    rl.registerAction("collection.get", {
+        description: "Get a collection by ID",
+        inputSchema: {
+            collectionId: { type: "string", required: true, description: "Collection ID" },
+        },
+        async execute(input, ctx) {
+            const { collectionId } = input;
+            return authedRequest(ctx, "GET", `/public/collections/${collectionId}`);
+        },
+    });
+    rl.registerAction("collection.list", {
+        description: "List all collections",
+        inputSchema: {
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { limit } = (input ?? {});
+            const data = (await authedRequest(ctx, "GET", "/public/collections"));
+            if (limit)
+                return data.data.slice(0, limit);
+            return data.data;
+        },
+    });
+    rl.registerAction("collection.update", {
+        description: "Update a collection",
+        inputSchema: {
+            collectionId: { type: "string", required: true, description: "Collection ID" },
+            groups: { type: "array", required: false, description: "Array of group IDs to assign" },
+            externalId: { type: "string", required: false, description: "External ID" },
+        },
+        async execute(input, ctx) {
+            const { collectionId, groups, externalId } = input;
+            const body = {};
+            if (groups) {
+                body.groups = groups.map((id) => ({ id, ReadOnly: false }));
+            }
+            if (externalId)
+                body.externalId = externalId;
+            return authedRequest(ctx, "PUT", `/public/collections/${collectionId}`, body);
+        },
+    });
+    rl.registerAction("collection.delete", {
+        description: "Delete a collection",
+        inputSchema: {
+            collectionId: { type: "string", required: true, description: "Collection ID" },
+        },
+        async execute(input, ctx) {
+            const { collectionId } = input;
+            await authedRequest(ctx, "DELETE", `/public/collections/${collectionId}`);
+            return { success: true };
+        },
+    });
+    // ── Event ───────────────────────────────────────────
+    rl.registerAction("event.list", {
+        description: "List organization events",
+        inputSchema: {
+            start: { type: "string", required: false, description: "Start date (ISO 8601)" },
+            end: { type: "string", required: false, description: "End date (ISO 8601)" },
+            actingUserId: { type: "string", required: false, description: "Filter by acting user ID" },
+            itemId: { type: "string", required: false, description: "Filter by item ID" },
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { limit, ...qs } = (input ?? {});
+            const data = (await authedRequest(ctx, "GET", "/public/events", undefined, qs));
+            if (limit)
+                return data.data.slice(0, limit);
+            return data.data;
+        },
+    });
+    // ── Group ───────────────────────────────────────────
+    rl.registerAction("group.create", {
+        description: "Create a group",
+        inputSchema: {
+            name: { type: "string", required: true, description: "Group name" },
+            accessAll: { type: "boolean", required: true, description: "Grant access to all collections" },
+            collections: { type: "array", required: false, description: "Array of collection IDs" },
+            externalId: { type: "string", required: false, description: "External ID" },
+        },
+        async execute(input, ctx) {
+            const { name, accessAll, collections, externalId } = input;
+            const body = { name, AccessAll: accessAll };
+            if (collections) {
+                body.collections = collections.map((id) => ({ id, ReadOnly: false }));
+            }
+            if (externalId)
+                body.externalId = externalId;
+            return authedRequest(ctx, "POST", "/public/groups", body);
+        },
+    });
+    rl.registerAction("group.get", {
+        description: "Get a group by ID",
+        inputSchema: {
+            groupId: { type: "string", required: true, description: "Group ID" },
+        },
+        async execute(input, ctx) {
+            const { groupId } = input;
+            return authedRequest(ctx, "GET", `/public/groups/${groupId}`);
+        },
+    });
+    rl.registerAction("group.list", {
+        description: "List all groups",
+        inputSchema: {
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { limit } = (input ?? {});
+            const data = (await authedRequest(ctx, "GET", "/public/groups"));
+            if (limit)
+                return data.data.slice(0, limit);
+            return data.data;
+        },
+    });
+    rl.registerAction("group.getMembers", {
+        description: "Get member IDs for a group",
+        inputSchema: {
+            groupId: { type: "string", required: true, description: "Group ID" },
+        },
+        async execute(input, ctx) {
+            const { groupId } = input;
+            const memberIds = (await authedRequest(ctx, "GET", `/public/groups/${groupId}/member-ids`));
+            return memberIds.map((memberId) => ({ memberId }));
+        },
+    });
+    rl.registerAction("group.update", {
+        description: "Update a group",
+        inputSchema: {
+            groupId: { type: "string", required: true, description: "Group ID" },
+            name: { type: "string", required: false, description: "Group name" },
+            accessAll: { type: "boolean", required: false, description: "Access all collections" },
+            collections: { type: "array", required: false, description: "Array of collection IDs" },
+            externalId: { type: "string", required: false, description: "External ID" },
+        },
+        async execute(input, ctx) {
+            const { groupId, name, accessAll, collections, externalId } = input;
+            const body = {};
+            // Name is required by API — fetch current if not provided
+            if (name) {
+                body.name = name;
+            }
+            else {
+                const current = (await authedRequest(ctx, "GET", `/public/groups/${groupId}`));
+                body.name = current.name;
+            }
+            body.AccessAll = accessAll ?? false;
+            if (collections) {
+                body.collections = collections.map((id) => ({ id, ReadOnly: false }));
+            }
+            if (externalId)
+                body.externalId = externalId;
+            return authedRequest(ctx, "PUT", `/public/groups/${groupId}`, body);
+        },
+    });
+    rl.registerAction("group.updateMembers", {
+        description: "Set the member IDs for a group",
+        inputSchema: {
+            groupId: { type: "string", required: true, description: "Group ID" },
+            memberIds: { type: "array", required: true, description: "Array of member IDs" },
+        },
+        async execute(input, ctx) {
+            const { groupId, memberIds } = input;
+            await authedRequest(ctx, "PUT", `/public/groups/${groupId}/member-ids`, { memberIds });
+            return { success: true };
+        },
+    });
+    rl.registerAction("group.delete", {
+        description: "Delete a group",
+        inputSchema: {
+            groupId: { type: "string", required: true, description: "Group ID" },
+        },
+        async execute(input, ctx) {
+            const { groupId } = input;
+            await authedRequest(ctx, "DELETE", `/public/groups/${groupId}`);
+            return { success: true };
+        },
+    });
+    // ── Member ──────────────────────────────────────────
+    rl.registerAction("member.create", {
+        description: "Invite a member to the organization",
+        inputSchema: {
+            email: { type: "string", required: true, description: "Email address" },
+            type: { type: "number", required: true, description: "Member type (0=Owner, 1=Admin, 2=User, 3=Manager)" },
+            accessAll: { type: "boolean", required: true, description: "Access all collections" },
+            collections: { type: "array", required: false, description: "Array of collection IDs" },
+            externalId: { type: "string", required: false, description: "External ID" },
+        },
+        async execute(input, ctx) {
+            const { email, type, accessAll, collections, externalId } = input;
+            const body = { email, type, AccessAll: accessAll };
+            if (collections) {
+                body.collections = collections.map((id) => ({ id, ReadOnly: false }));
+            }
+            if (externalId)
+                body.externalId = externalId;
+            return authedRequest(ctx, "POST", "/public/members/", body);
+        },
+    });
+    rl.registerAction("member.get", {
+        description: "Get a member by ID",
+        inputSchema: {
+            memberId: { type: "string", required: true, description: "Member ID" },
+        },
+        async execute(input, ctx) {
+            const { memberId } = input;
+            return authedRequest(ctx, "GET", `/public/members/${memberId}`);
+        },
+    });
+    rl.registerAction("member.list", {
+        description: "List all members",
+        inputSchema: {
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { limit } = (input ?? {});
+            const data = (await authedRequest(ctx, "GET", "/public/members"));
+            if (limit)
+                return data.data.slice(0, limit);
+            return data.data;
+        },
+    });
+    rl.registerAction("member.getGroups", {
+        description: "Get group IDs for a member",
+        inputSchema: {
+            memberId: { type: "string", required: true, description: "Member ID" },
+        },
+        async execute(input, ctx) {
+            const { memberId } = input;
+            const groupIds = (await authedRequest(ctx, "GET", `/public/members/${memberId}/group-ids`));
+            return groupIds.map((groupId) => ({ groupId }));
+        },
+    });
+    rl.registerAction("member.update", {
+        description: "Update a member",
+        inputSchema: {
+            memberId: { type: "string", required: true, description: "Member ID" },
+            type: { type: "number", required: false, description: "Member type (0=Owner, 1=Admin, 2=User, 3=Manager)" },
+            accessAll: { type: "boolean", required: false, description: "Access all collections" },
+            collections: { type: "array", required: false, description: "Array of collection IDs" },
+            externalId: { type: "string", required: false, description: "External ID" },
+        },
+        async execute(input, ctx) {
+            const { memberId, type, accessAll, collections, externalId } = input;
+            const body = {};
+            if (accessAll !== undefined)
+                body.AccessAll = accessAll;
+            if (type !== undefined)
+                body.Type = type;
+            if (collections) {
+                body.collections = collections.map((id) => ({ id, ReadOnly: false }));
+            }
+            if (externalId)
+                body.externalId = externalId;
+            return authedRequest(ctx, "PUT", `/public/members/${memberId}`, body);
+        },
+    });
+    rl.registerAction("member.updateGroups", {
+        description: "Set the group IDs for a member",
+        inputSchema: {
+            memberId: { type: "string", required: true, description: "Member ID" },
+            groupIds: { type: "array", required: true, description: "Array of group IDs" },
+        },
+        async execute(input, ctx) {
+            const { memberId, groupIds } = input;
+            await authedRequest(ctx, "PUT", `/public/members/${memberId}/group-ids`, { groupIds });
+            return { success: true };
+        },
+    });
+    rl.registerAction("member.delete", {
+        description: "Remove a member from the organization",
+        inputSchema: {
+            memberId: { type: "string", required: true, description: "Member ID" },
+        },
+        async execute(input, ctx) {
+            const { memberId } = input;
+            await authedRequest(ctx, "DELETE", `/public/members/${memberId}`);
+            return { success: true };
+        },
+    });
+}

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

@@ -0,0 +1,300 @@
+const BASE_URL = "https://api.box.com/2.0";
+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(`Box 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(token, endpoint, property, qs, limit) {
+    const results = [];
+    let offset = 0;
+    const size = 100;
+    while (true) {
+        const data = (await apiRequest(token, "GET", endpoint, undefined, {
+            ...qs,
+            limit: size,
+            offset,
+        }));
+        const items = data[property] ?? [];
+        results.push(...items);
+        if (limit && results.length >= limit)
+            return results.slice(0, limit);
+        if (items.length === 0)
+            break;
+        offset += size;
+    }
+    return results;
+}
+function getToken(ctx) {
+    return ctx.connection.config.accessToken;
+}
+export default function box(rl) {
+    rl.setName("box");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        accessToken: {
+            type: "string",
+            required: true,
+            description: "Box OAuth2 access token (or developer token for testing)",
+            env: "BOX_ACCESS_TOKEN",
+        },
+    });
+    // ── File ────────────────────────────────────────────
+    rl.registerAction("file.copy", {
+        description: "Copy a file to a folder",
+        inputSchema: {
+            fileId: { type: "string", required: true, description: "File ID" },
+            parentId: { type: "string", required: true, description: "Destination folder ID (0 for root)" },
+            name: { type: "string", required: false, description: "New name for the copy" },
+            version: { type: "string", required: false, description: "Specific version to copy" },
+            fields: { type: "string", required: false, description: "Comma-separated fields to return" },
+        },
+        async execute(input, ctx) {
+            const { fileId, parentId, name, version, fields } = input;
+            const body = { parent: { id: parentId || "0" } };
+            if (name)
+                body.name = name;
+            if (version)
+                body.version = version;
+            const qs = {};
+            if (fields)
+                qs.fields = fields;
+            return apiRequest(getToken(ctx), "POST", `/files/${fileId}/copy`, body, qs);
+        },
+    });
+    rl.registerAction("file.delete", {
+        description: "Delete a file",
+        inputSchema: {
+            fileId: { type: "string", required: true, description: "File ID" },
+        },
+        async execute(input, ctx) {
+            const { fileId } = input;
+            await apiRequest(getToken(ctx), "DELETE", `/files/${fileId}`);
+            return { success: true };
+        },
+    });
+    rl.registerAction("file.get", {
+        description: "Get file metadata",
+        inputSchema: {
+            fileId: { type: "string", required: true, description: "File ID" },
+            fields: { type: "string", required: false, description: "Comma-separated fields to return" },
+        },
+        async execute(input, ctx) {
+            const { fileId, fields } = input;
+            const qs = {};
+            if (fields)
+                qs.fields = fields;
+            return apiRequest(getToken(ctx), "GET", `/files/${fileId}`, undefined, qs);
+        },
+    });
+    rl.registerAction("file.search", {
+        description: "Search for files",
+        inputSchema: {
+            query: { type: "string", required: true, description: "Search query" },
+            limit: { type: "number", required: false, description: "Max results" },
+            contentTypes: { type: "string", required: false, description: "Comma-separated content types (name, description, file_content, comments, tags)" },
+            createdAtRange: { type: "string", required: false, description: "Date range: from,to (ISO 8601)" },
+            updatedAtRange: { type: "string", required: false, description: "Date range: from,to (ISO 8601)" },
+            ancestorFolderIds: { type: "string", required: false, description: "Comma-separated folder IDs to search within" },
+        },
+        async execute(input, ctx) {
+            const { query, limit, contentTypes, createdAtRange, updatedAtRange, ancestorFolderIds } = (input ?? {});
+            const qs = { type: "file", query };
+            if (contentTypes)
+                qs.content_types = contentTypes;
+            if (createdAtRange)
+                qs.created_at_range = createdAtRange;
+            if (updatedAtRange)
+                qs.updated_at_range = updatedAtRange;
+            if (ancestorFolderIds)
+                qs.ancestor_folder_ids = ancestorFolderIds;
+            return paginateAll(getToken(ctx), "/search", "entries", qs, limit);
+        },
+    });
+    rl.registerAction("file.share", {
+        description: "Share a file (create a collaboration)",
+        inputSchema: {
+            fileId: { type: "string", required: true, description: "File ID" },
+            role: { type: "string", required: true, description: "Role: editor, viewer, previewer, uploader, previewer_uploader, viewer_uploader, co-owner" },
+            accessibleByType: { type: "string", required: true, description: "'user' or 'group'" },
+            accessibleById: { type: "string", required: false, description: "User/group ID (use this or email)" },
+            email: { type: "string", required: false, description: "User email (alternative to ID, only for user type)" },
+            canViewPath: { type: "boolean", required: false, description: "Can view path to this item" },
+            expiresAt: { type: "string", required: false, description: "Expiration date (ISO 8601)" },
+            notify: { type: "boolean", required: false, description: "Send notification email" },
+        },
+        async execute(input, ctx) {
+            const { fileId, role, accessibleByType, accessibleById, email, canViewPath, expiresAt, notify } = input;
+            const body = {
+                item: { id: fileId, type: "file" },
+                role,
+                accessible_by: {},
+            };
+            const accessible = body.accessible_by;
+            accessible.type = accessibleByType;
+            if (email)
+                accessible.login = email;
+            else if (accessibleById)
+                accessible.id = accessibleById;
+            if (canViewPath !== undefined)
+                body.can_view_path = canViewPath;
+            if (expiresAt)
+                body.expires_at = expiresAt;
+            const qs = {};
+            if (notify !== undefined)
+                qs.notify = notify;
+            return apiRequest(getToken(ctx), "POST", "/collaborations", body, qs);
+        },
+    });
+    // ── Folder ──────────────────────────────────────────
+    rl.registerAction("folder.create", {
+        description: "Create a folder",
+        inputSchema: {
+            name: { type: "string", required: true, description: "Folder name" },
+            parentId: { type: "string", required: false, description: "Parent folder ID (0 for root)" },
+            fields: { type: "string", required: false, description: "Comma-separated fields to return" },
+        },
+        async execute(input, ctx) {
+            const { name, parentId, fields } = input;
+            const body = {
+                name,
+                parent: { id: parentId || "0" },
+            };
+            const qs = {};
+            if (fields)
+                qs.fields = fields;
+            return apiRequest(getToken(ctx), "POST", "/folders", body, qs);
+        },
+    });
+    rl.registerAction("folder.delete", {
+        description: "Delete a folder",
+        inputSchema: {
+            folderId: { type: "string", required: true, description: "Folder ID" },
+            recursive: { type: "boolean", required: false, description: "Delete non-empty folder recursively" },
+        },
+        async execute(input, ctx) {
+            const { folderId, recursive } = input;
+            await apiRequest(getToken(ctx), "DELETE", `/folders/${folderId}`, undefined, {
+                recursive: recursive ?? false,
+            });
+            return { success: true };
+        },
+    });
+    rl.registerAction("folder.get", {
+        description: "Get folder metadata",
+        inputSchema: {
+            folderId: { type: "string", required: true, description: "Folder ID" },
+        },
+        async execute(input, ctx) {
+            const { folderId } = input;
+            return apiRequest(getToken(ctx), "GET", `/folders/${folderId}`);
+        },
+    });
+    rl.registerAction("folder.search", {
+        description: "Search for folders",
+        inputSchema: {
+            query: { type: "string", required: true, description: "Search query" },
+            limit: { type: "number", required: false, description: "Max results" },
+            contentTypes: { type: "string", required: false, description: "Comma-separated content types" },
+            createdAtRange: { type: "string", required: false, description: "Date range: from,to (ISO 8601)" },
+            updatedAtRange: { type: "string", required: false, description: "Date range: from,to (ISO 8601)" },
+        },
+        async execute(input, ctx) {
+            const { query, limit, contentTypes, createdAtRange, updatedAtRange } = (input ?? {});
+            const qs = { type: "folder", query };
+            if (contentTypes)
+                qs.content_types = contentTypes;
+            if (createdAtRange)
+                qs.created_at_range = createdAtRange;
+            if (updatedAtRange)
+                qs.updated_at_range = updatedAtRange;
+            return paginateAll(getToken(ctx), "/search", "entries", qs, limit);
+        },
+    });
+    rl.registerAction("folder.share", {
+        description: "Share a folder (create a collaboration)",
+        inputSchema: {
+            folderId: { type: "string", required: true, description: "Folder ID" },
+            role: { type: "string", required: true, description: "Role: editor, viewer, previewer, uploader, previewer_uploader, viewer_uploader, co-owner" },
+            accessibleByType: { type: "string", required: true, description: "'user' or 'group'" },
+            accessibleById: { type: "string", required: false, description: "User/group ID" },
+            email: { type: "string", required: false, description: "User email (alternative to ID)" },
+            canViewPath: { type: "boolean", required: false, description: "Can view path" },
+            expiresAt: { type: "string", required: false, description: "Expiration (ISO 8601)" },
+            notify: { type: "boolean", required: false, description: "Send notification" },
+        },
+        async execute(input, ctx) {
+            const { folderId, role, accessibleByType, accessibleById, email, canViewPath, expiresAt, notify } = input;
+            const body = {
+                item: { id: folderId, type: "folder" },
+                role,
+                accessible_by: {},
+            };
+            const accessible = body.accessible_by;
+            accessible.type = accessibleByType;
+            if (email)
+                accessible.login = email;
+            else if (accessibleById)
+                accessible.id = accessibleById;
+            if (canViewPath !== undefined)
+                body.can_view_path = canViewPath;
+            if (expiresAt)
+                body.expires_at = expiresAt;
+            const qs = {};
+            if (notify !== undefined)
+                qs.notify = notify;
+            return apiRequest(getToken(ctx), "POST", "/collaborations", body, qs);
+        },
+    });
+    rl.registerAction("folder.update", {
+        description: "Update a folder (move, rename, tag)",
+        inputSchema: {
+            folderId: { type: "string", required: true, description: "Folder ID" },
+            name: { type: "string", required: false, description: "New name" },
+            parentId: { type: "string", required: false, description: "Move to this parent folder ID" },
+            description: { type: "string", required: false, description: "Description" },
+            tags: { type: "string", required: false, description: "Comma-separated tags" },
+            fields: { type: "string", required: false, description: "Fields to return" },
+        },
+        async execute(input, ctx) {
+            const { folderId, name, parentId, description, tags, fields } = input;
+            const body = {};
+            if (name)
+                body.name = name;
+            if (parentId)
+                body.parent = { id: parentId };
+            if (description)
+                body.description = description;
+            if (tags)
+                body.tags = tags.split(",").map((t) => t.trim());
+            const qs = {};
+            if (fields)
+                qs.fields = fields;
+            return apiRequest(getToken(ctx), "PUT", `/folders/${folderId}`, body, qs);
+        },
+    });
+}