runline 0.1.0

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

@@ -0,0 +1,131 @@
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    const url = c.url.replace(/\/$/, "");
+    return { url, username: c.username, password: c.password };
+}
+async function apiRequest(conn, method, resource, body) {
+    const init = {
+        method,
+        headers: {
+            "Content-Type": "application/json",
+            "X-NITRO-USER": conn.username,
+            "X-NITRO-PASS": conn.password,
+        },
+    };
+    if (body && Object.keys(body).length > 0)
+        init.body = JSON.stringify(body);
+    const res = await fetch(`${conn.url}/nitro/v1${resource}`, init);
+    if (!res.ok)
+        throw new Error(`Netscaler ADC API error ${res.status}: ${await res.text()}`);
+    const text = await res.text();
+    return text ? JSON.parse(text) : {};
+}
+export default function netscalerAdc(rl) {
+    rl.setName("netscalerAdc");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        url: { type: "string", required: true, description: "Netscaler ADC base URL (e.g. https://adc.example.com)", env: "NETSCALER_URL" },
+        username: { type: "string", required: true, description: "Nitro API username", env: "NETSCALER_USERNAME" },
+        password: { type: "string", required: true, description: "Nitro API password", env: "NETSCALER_PASSWORD" },
+    });
+    rl.registerAction("certificate.create", {
+        description: "Create an SSL certificate on the appliance",
+        inputSchema: {
+            certificateFileName: { type: "string", required: true, description: "Name (and optional path) for the generated certificate file. Default path: /nsconfig/ssl/" },
+            certificateFormat: { type: "string", required: true, description: "PEM or DER" },
+            certificateType: { type: "string", required: true, description: "ROOT_CERT, INTM_CERT, SRVR_CERT, or CLNT_CERT" },
+            certificateRequestFileName: { type: "string", required: true, description: "Name/path for the CSR file" },
+            privateKeyFileName: { type: "string", required: false, description: "Private key file name (required for ROOT_CERT)" },
+            caCertificateFileName: { type: "string", required: false, description: "CA certificate file (required for non-ROOT_CERT)" },
+            caCertificateFileFormat: { type: "string", required: false, description: "PEM or DER (for CA cert)" },
+            caPrivateKeyFileName: { type: "string", required: false, description: "CA private key file" },
+            caPrivateKeyFileFormat: { type: "string", required: false, description: "PEM or DER (for CA key)" },
+            caSerialFileNumber: { type: "string", required: false, description: "CA serial number file" },
+            pempassphrase: { type: "string", required: false, description: "PEM passphrase for encrypted key" },
+            subjectaltname: { type: "string", required: false, description: "Subject Alternative Name (SAN)" },
+            days: { type: "string", required: false, description: "Validity period in days" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const conn = getConn(ctx);
+            const body = {
+                reqfile: p.certificateRequestFileName,
+                certfile: p.certificateFileName,
+                certform: p.certificateFormat,
+                certType: p.certificateType,
+            };
+            if (p.certificateType === "ROOT_CERT") {
+                if (p.privateKeyFileName)
+                    body.keyfile = p.privateKeyFileName;
+            }
+            else {
+                if (p.caCertificateFileName)
+                    body.cacert = p.caCertificateFileName;
+                if (p.caCertificateFileFormat)
+                    body.cacertform = p.caCertificateFileFormat;
+                if (p.caPrivateKeyFileName)
+                    body.cakey = p.caPrivateKeyFileName;
+                if (p.caPrivateKeyFileFormat)
+                    body.cakeyform = p.caPrivateKeyFileFormat;
+                if (p.caSerialFileNumber)
+                    body.caserial = p.caSerialFileNumber;
+            }
+            if (p.pempassphrase)
+                body.pempassphrase = p.pempassphrase;
+            if (p.subjectaltname)
+                body.subjectaltname = p.subjectaltname;
+            if (p.days)
+                body.days = p.days;
+            await apiRequest(conn, "POST", "/config/sslcert?action=create", { sslcert: body });
+            return { success: true };
+        },
+    });
+    rl.registerAction("certificate.install", {
+        description: "Install an SSL certificate-key pair on the appliance",
+        inputSchema: {
+            certificateKeyPairName: { type: "string", required: true, description: "Name for the certificate-key pair" },
+            certificateFileName: { type: "string", required: true, description: "X509 certificate file name/path" },
+            privateKeyFileName: { type: "string", required: true, description: "Private key file name/path" },
+            certificateFormat: { type: "string", required: true, description: "PEM or DER" },
+            password: { type: "string", required: false, description: "PEM passphrase (required for PEM format)" },
+            certificateBundle: { type: "boolean", required: false, description: "Parse certificate chain as single file (PEM only)" },
+            notifyExpiration: { type: "boolean", required: false, description: "Alert when certificate is about to expire" },
+            notificationPeriod: { type: "number", required: false, description: "Days before expiry to alert (10-100, default 10)" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const conn = getConn(ctx);
+            const body = {
+                certkey: p.certificateKeyPairName,
+                cert: p.certificateFileName,
+                key: p.privateKeyFileName,
+                inform: p.certificateFormat,
+            };
+            if (p.certificateFormat === "PEM") {
+                if (p.password)
+                    body.passplain = p.password;
+                body.bundle = p.certificateBundle ? "YES" : "NO";
+            }
+            if (p.notifyExpiration) {
+                body.expirymonitor = "ENABLED";
+                body.notificationperiod = p.notificationPeriod ?? 10;
+            }
+            await apiRequest(conn, "POST", "/config/sslcertkey", { sslcertkey: body });
+            return { success: true };
+        },
+    });
+    rl.registerAction("file.delete", {
+        description: "Delete a file from the Netscaler ADC appliance",
+        inputSchema: {
+            fileName: { type: "string", required: true, description: "File name (without path)" },
+            fileLocation: { type: "string", required: false, description: "File location (default /nsconfig/ssl/)" },
+        },
+        async execute(input, ctx) {
+            const { fileName, fileLocation } = input;
+            const conn = getConn(ctx);
+            const loc = encodeURIComponent(fileLocation ?? "/nsconfig/ssl/");
+            await apiRequest(conn, "DELETE", `/config/systemfile?args=filename:${fileName},filelocation:${loc}`);
+            return { success: true };
+        },
+    });
+}

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

@@ -0,0 +1,263 @@
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    return {
+        webDavUrl: c.webDavUrl.replace(/\/$/, ""),
+        username: c.username,
+        password: c.password,
+    };
+}
+function authHeader(conn) {
+    // Nextcloud uses Basic auth for access token API
+    return "Basic " + btoa(`${conn.username}:${conn.password}`);
+}
+/** Base URL without /remote.php/webdav — for OCS and share APIs */
+function baseUrl(conn) {
+    return conn.webDavUrl.replace("/remote.php/webdav", "");
+}
+/** Make a WebDAV request */
+async function webdavRequest(conn, method, path, headers) {
+    const url = `${conn.webDavUrl}/${encodeURI(path.replace(/^\//, ""))}`;
+    const res = await fetch(url, {
+        method,
+        headers: { Authorization: authHeader(conn), ...headers },
+    });
+    if (!res.ok)
+        throw new Error(`Nextcloud WebDAV error ${res.status}: ${await res.text()}`);
+    return res.text();
+}
+/** Make an OCS API request (returns XML text) */
+async function ocsRequest(conn, method, endpoint, body, qs) {
+    const url = new URL(`${baseUrl(conn)}/${endpoint}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    // Request JSON format via OCS
+    url.searchParams.set("format", "json");
+    const headers = {
+        Authorization: authHeader(conn),
+        "OCS-APIRequest": "true",
+    };
+    const init = { method, headers };
+    if (body) {
+        headers["Content-Type"] = "application/x-www-form-urlencoded";
+        init.body = body;
+    }
+    const res = await fetch(url.toString(), init);
+    if (!res.ok)
+        throw new Error(`Nextcloud OCS error ${res.status}: ${await res.text()}`);
+    return res.text();
+}
+/** Parse OCS JSON response */
+function parseOcs(text) {
+    const json = JSON.parse(text);
+    const meta = json?.ocs?.meta;
+    if (meta && meta.status !== "ok" && meta.statuscode >= 300) {
+        throw new Error(`Nextcloud OCS error: ${meta.message || meta.status}`);
+    }
+    return json?.ocs?.data;
+}
+export default function nextcloud(rl) {
+    rl.setName("nextcloud");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        webDavUrl: { type: "string", required: true, description: "Nextcloud WebDAV URL (e.g. https://cloud.example.com/remote.php/webdav)", env: "NEXTCLOUD_WEBDAV_URL" },
+        username: { type: "string", required: true, description: "Nextcloud username", env: "NEXTCLOUD_USERNAME" },
+        password: { type: "string", required: true, description: "Nextcloud password or app token", env: "NEXTCLOUD_PASSWORD" },
+    });
+    // ── File/Folder operations (non-binary) ─────────────
+    rl.registerAction("file.copy", {
+        description: "Copy a file on Nextcloud",
+        inputSchema: {
+            path: { type: "string", required: true, description: "Source file path (e.g. /invoices/original.txt)" },
+            toPath: { type: "string", required: true, description: "Destination file path" },
+        },
+        async execute(input, ctx) {
+            const { path, toPath } = input;
+            const conn = getConn(ctx);
+            await webdavRequest(conn, "COPY", path, {
+                Destination: `${conn.webDavUrl}/${encodeURI(toPath.replace(/^\//, ""))}`,
+            });
+            return { success: true };
+        },
+    });
+    rl.registerAction("file.delete", {
+        description: "Delete a file on Nextcloud",
+        inputSchema: {
+            path: { type: "string", required: true, description: "File path to delete" },
+        },
+        async execute(input, ctx) {
+            const { path } = input;
+            await webdavRequest(getConn(ctx), "DELETE", path);
+            return { success: true };
+        },
+    });
+    rl.registerAction("file.move", {
+        description: "Move/rename a file on Nextcloud",
+        inputSchema: {
+            path: { type: "string", required: true, description: "Source file path" },
+            toPath: { type: "string", required: true, description: "Destination file path" },
+        },
+        async execute(input, ctx) {
+            const { path, toPath } = input;
+            const conn = getConn(ctx);
+            await webdavRequest(conn, "MOVE", path, {
+                Destination: `${conn.webDavUrl}/${encodeURI(toPath.replace(/^\//, ""))}`,
+            });
+            return { success: true };
+        },
+    });
+    rl.registerAction("file.share", {
+        description: "Share a file or folder via Nextcloud sharing API",
+        inputSchema: {
+            path: { type: "string", required: true, description: "File/folder path to share" },
+            shareType: { type: "number", required: true, description: "0=user, 1=group, 3=public link, 4=email, 7=circle" },
+            shareWith: { type: "string", required: false, description: "User, group, email, or circle ID to share with (not needed for public link)" },
+            permissions: { type: "number", required: false, description: "1=read, 2=update, 4=create, 8=delete, 31=all (default 1)" },
+            password: { type: "string", required: false, description: "Password for public link shares" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const params = new URLSearchParams();
+            params.set("path", p.path);
+            params.set("shareType", String(p.shareType));
+            if (p.shareWith)
+                params.set("shareWith", p.shareWith);
+            if (p.permissions)
+                params.set("permissions", String(p.permissions));
+            if (p.password)
+                params.set("password", p.password);
+            const text = await ocsRequest(getConn(ctx), "POST", "ocs/v2.php/apps/files_sharing/api/v1/shares", params.toString());
+            return parseOcs(text);
+        },
+    });
+    rl.registerAction("folder.create", {
+        description: "Create a folder on Nextcloud",
+        inputSchema: {
+            path: { type: "string", required: true, description: "Folder path to create (e.g. /invoices/2019)" },
+        },
+        async execute(input, ctx) {
+            const { path } = input;
+            await webdavRequest(getConn(ctx), "MKCOL", path);
+            return { success: true };
+        },
+    });
+    rl.registerAction("folder.delete", {
+        description: "Delete a folder on Nextcloud",
+        inputSchema: {
+            path: { type: "string", required: true, description: "Folder path to delete" },
+        },
+        async execute(input, ctx) {
+            const { path } = input;
+            await webdavRequest(getConn(ctx), "DELETE", path);
+            return { success: true };
+        },
+    });
+    rl.registerAction("folder.copy", {
+        description: "Copy a folder on Nextcloud",
+        inputSchema: {
+            path: { type: "string", required: true, description: "Source folder path" },
+            toPath: { type: "string", required: true, description: "Destination folder path" },
+        },
+        async execute(input, ctx) {
+            const { path, toPath } = input;
+            const conn = getConn(ctx);
+            await webdavRequest(conn, "COPY", path, {
+                Destination: `${conn.webDavUrl}/${encodeURI(toPath.replace(/^\//, ""))}`,
+            });
+            return { success: true };
+        },
+    });
+    rl.registerAction("folder.move", {
+        description: "Move/rename a folder on Nextcloud",
+        inputSchema: {
+            path: { type: "string", required: true, description: "Source folder path" },
+            toPath: { type: "string", required: true, description: "Destination folder path" },
+        },
+        async execute(input, ctx) {
+            const { path, toPath } = input;
+            const conn = getConn(ctx);
+            await webdavRequest(conn, "MOVE", path, {
+                Destination: `${conn.webDavUrl}/${encodeURI(toPath.replace(/^\//, ""))}`,
+            });
+            return { success: true };
+        },
+    });
+    // ── User operations ─────────────────────────────────
+    rl.registerAction("user.create", {
+        description: "Create a user on Nextcloud",
+        inputSchema: {
+            userId: { type: "string", required: true, description: "Username" },
+            email: { type: "string", required: true, description: "Email address" },
+            displayName: { type: "string", required: false, description: "Display name" },
+        },
+        async execute(input, ctx) {
+            const { userId, email, displayName } = input;
+            const params = new URLSearchParams();
+            params.set("userid", userId);
+            params.set("email", email);
+            if (displayName)
+                params.set("displayName", displayName);
+            const text = await ocsRequest(getConn(ctx), "POST", "ocs/v1.php/cloud/users", params.toString());
+            return parseOcs(text);
+        },
+    });
+    rl.registerAction("user.delete", {
+        description: "Delete a user on Nextcloud",
+        inputSchema: {
+            userId: { type: "string", required: true, description: "Username" },
+        },
+        async execute(input, ctx) {
+            const { userId } = input;
+            const text = await ocsRequest(getConn(ctx), "DELETE", `ocs/v1.php/cloud/users/${userId}`);
+            return parseOcs(text);
+        },
+    });
+    rl.registerAction("user.get", {
+        description: "Get a user's information",
+        inputSchema: {
+            userId: { type: "string", required: true, description: "Username" },
+        },
+        async execute(input, ctx) {
+            const { userId } = input;
+            const text = await ocsRequest(getConn(ctx), "GET", `ocs/v1.php/cloud/users/${userId}`);
+            return parseOcs(text);
+        },
+    });
+    rl.registerAction("user.list", {
+        description: "List all users",
+        inputSchema: {
+            limit: { type: "number", required: false, description: "Max results" },
+            offset: { type: "number", required: false, description: "Offset" },
+            search: { type: "string", required: false, description: "Search string" },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.limit)
+                qs.limit = p.limit;
+            if (p.offset)
+                qs.offset = p.offset;
+            if (p.search)
+                qs.search = p.search;
+            const text = await ocsRequest(getConn(ctx), "GET", "ocs/v1.php/cloud/users", undefined, qs);
+            return parseOcs(text);
+        },
+    });
+    rl.registerAction("user.update", {
+        description: "Update a user attribute (email, displayname, password, address, twitter, website)",
+        inputSchema: {
+            userId: { type: "string", required: true, description: "Username" },
+            key: { type: "string", required: true, description: "Attribute key: email, displayname, password, address, twitter, website" },
+            value: { type: "string", required: true, description: "New value" },
+        },
+        async execute(input, ctx) {
+            const { userId, key, value } = input;
+            const body = `key=${encodeURIComponent(key)}&value=${encodeURIComponent(value)}`;
+            const text = await ocsRequest(getConn(ctx), "PUT", `ocs/v1.php/cloud/users/${userId}`, body);
+            return parseOcs(text);
+        },
+    });
+}

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

@@ -0,0 +1,130 @@
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    const host = c.host.replace(/\/$/, "");
+    return { host, token: c.apiToken };
+}
+async function apiRequest(conn, method, endpoint, body, qs) {
+    const url = new URL(`${conn.host}${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: {
+            "xc-token": conn.token,
+            "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(`NocoDB API error ${res.status}: ${await res.text()}`);
+    const text = await res.text();
+    return text ? JSON.parse(text) : {};
+}
+async function paginate(conn, endpoint, qs = {}) {
+    const all = [];
+    qs.limit = 100;
+    qs.offset = 0;
+    let isLast = false;
+    while (!isLast) {
+        const data = (await apiRequest(conn, "GET", endpoint, undefined, qs));
+        const list = (data.list ?? []);
+        all.push(...list);
+        const pageInfo = data.pageInfo;
+        isLast = pageInfo?.isLastPage === true || list.length === 0;
+        qs.offset = qs.offset + qs.limit;
+    }
+    return all;
+}
+export default function nocodb(rl) {
+    rl.setName("nocodb");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        host: { type: "string", required: true, description: "NocoDB host URL (e.g. https://nocodb.example.com)", env: "NOCODB_HOST" },
+        apiToken: { type: "string", required: true, description: "NocoDB API token (xc-token)", env: "NOCODB_API_TOKEN" },
+    });
+    rl.registerAction("row.create", {
+        description: "Create one or more rows in a NocoDB table (v2 API)",
+        inputSchema: {
+            tableId: { type: "string", required: true, description: "Table ID" },
+            rows: { type: "object", required: true, description: "Array of row objects to create" },
+        },
+        async execute(input, ctx) {
+            const { tableId, rows } = input;
+            const conn = getConn(ctx);
+            return apiRequest(conn, "POST", `/api/v2/tables/${tableId}/records`, rows);
+        },
+    });
+    rl.registerAction("row.get", {
+        description: "Get a single row by ID",
+        inputSchema: {
+            tableId: { type: "string", required: true, description: "Table ID" },
+            rowId: { type: "string", required: true, description: "Row ID" },
+        },
+        async execute(input, ctx) {
+            const { tableId, rowId } = input;
+            return apiRequest(getConn(ctx), "GET", `/api/v2/tables/${tableId}/records/${rowId}`);
+        },
+    });
+    rl.registerAction("row.list", {
+        description: "List rows from a NocoDB table",
+        inputSchema: {
+            tableId: { type: "string", required: true, description: "Table ID" },
+            limit: { type: "number", required: false, description: "Max rows to return (default: all)" },
+            where: { type: "string", required: false, description: "Filter formula, e.g. (name,like,example%)" },
+            sort: { type: "string", required: false, description: "Sort string, e.g. -fieldName for desc" },
+            fields: { type: "string", required: false, description: "Comma-separated field names to return" },
+            viewId: { type: "string", required: false, description: "View ID to filter by" },
+            offset: { type: "number", required: false, description: "Offset for pagination" },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const conn = getConn(ctx);
+            const endpoint = `/api/v2/tables/${p.tableId}/records`;
+            const qs = {};
+            if (p.where)
+                qs.where = p.where;
+            if (p.sort)
+                qs.sort = p.sort;
+            if (p.fields)
+                qs.fields = p.fields;
+            if (p.viewId)
+                qs.viewId = p.viewId;
+            if (p.offset)
+                qs.offset = p.offset;
+            if (p.limit) {
+                qs.limit = p.limit;
+                const data = (await apiRequest(conn, "GET", endpoint, undefined, qs));
+                return data.list;
+            }
+            return paginate(conn, endpoint, qs);
+        },
+    });
+    rl.registerAction("row.update", {
+        description: "Update one or more rows (include primary key in each row object)",
+        inputSchema: {
+            tableId: { type: "string", required: true, description: "Table ID" },
+            rows: { type: "object", required: true, description: "Array of row objects with primary key included" },
+        },
+        async execute(input, ctx) {
+            const { tableId, rows } = input;
+            return apiRequest(getConn(ctx), "PATCH", `/api/v2/tables/${tableId}/records`, rows);
+        },
+    });
+    rl.registerAction("row.delete", {
+        description: "Delete one or more rows by ID",
+        inputSchema: {
+            tableId: { type: "string", required: true, description: "Table ID" },
+            ids: { type: "object", required: true, description: "Array of objects with primary key, e.g. [{Id: 1}, {Id: 2}]" },
+        },
+        async execute(input, ctx) {
+            const { tableId, ids } = input;
+            return apiRequest(getConn(ctx), "DELETE", `/api/v2/tables/${tableId}/records`, ids);
+        },
+    });
+}

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

@@ -0,0 +1,112 @@
+const BASE = "https://api.notion.com/v1";
+const NOTION_VERSION = "2021-08-16";
+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}`, "Notion-Version": NOTION_VERSION, "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(`Notion error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+export default function notion(rl) {
+    rl.setName("notion");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({ apiKey: { type: "string", required: true, description: "Notion integration token (secret_...)", env: "NOTION_API_KEY" } });
+    const t = (ctx) => ctx.connection.config.apiKey;
+    // ── Block ───────────────────────────────────────────
+    rl.registerAction("block.append", { description: "Append children blocks to a block/page",
+        inputSchema: { blockId: { type: "string", required: true }, children: { type: "object", required: true, description: "Array of block objects" } },
+        async execute(input, ctx) { const p = input; return api(t(ctx), "PATCH", `/blocks/${p.blockId}/children`, { children: p.children }); } });
+    rl.registerAction("block.getChildren", { description: "Get child blocks of a block/page",
+        inputSchema: { blockId: { type: "string", required: true }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const qs = {};
+            if (p.limit)
+                qs.page_size = p.limit;
+            const data = (await api(t(ctx), "GET", `/blocks/${p.blockId}/children`, undefined, qs));
+            return data.results;
+        } });
+    rl.registerAction("block.delete", { description: "Delete (archive) a block",
+        inputSchema: { blockId: { type: "string", required: true } },
+        async execute(input, ctx) { return api(t(ctx), "DELETE", `/blocks/${input.blockId}`); } });
+    // ── Database ────────────────────────────────────────
+    rl.registerAction("database.get", { description: "Get a database",
+        inputSchema: { databaseId: { type: "string", required: true } },
+        async execute(input, ctx) { return api(t(ctx), "GET", `/databases/${input.databaseId}`); } });
+    rl.registerAction("database.list", { description: "List all databases (via search)",
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const body = { filter: { property: "object", value: "database" } };
+            if (input?.limit)
+                body.page_size = input.limit;
+            const data = (await api(t(ctx), "POST", "/search", body));
+            return data.results;
+        } });
+    rl.registerAction("database.query", { description: "Query a database (list pages with filters)",
+        inputSchema: { databaseId: { type: "string", required: true }, filter: { type: "object", required: false, description: "Notion filter object" }, sorts: { type: "object", required: false, description: "Array of sort objects" }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const body = {};
+            if (p.filter)
+                body.filter = p.filter;
+            if (p.sorts)
+                body.sorts = p.sorts;
+            if (p.limit)
+                body.page_size = p.limit;
+            const data = (await api(t(ctx), "POST", `/databases/${p.databaseId}/query`, body));
+            return data.results;
+        } });
+    // ── Page ────────────────────────────────────────────
+    rl.registerAction("page.create", { description: "Create a page (in a database or under a page)",
+        inputSchema: { parent: { type: "object", required: true, description: "{ database_id: '...' } or { page_id: '...' }" }, properties: { type: "object", required: true, description: "Page properties" }, children: { type: "object", required: false, description: "Array of block children" }, icon: { type: "object", required: false } },
+        async execute(input, ctx) { return api(t(ctx), "POST", "/pages", input); } });
+    rl.registerAction("page.get", { description: "Get a page",
+        inputSchema: { pageId: { type: "string", required: true } },
+        async execute(input, ctx) { return api(t(ctx), "GET", `/pages/${input.pageId}`); } });
+    rl.registerAction("page.update", { description: "Update page properties",
+        inputSchema: { pageId: { type: "string", required: true }, properties: { type: "object", required: false }, archived: { type: "boolean", required: false }, icon: { type: "object", required: false } },
+        async execute(input, ctx) {
+            const { pageId, ...body } = input;
+            return api(t(ctx), "PATCH", `/pages/${pageId}`, body);
+        } });
+    rl.registerAction("page.archive", { description: "Archive a page",
+        inputSchema: { pageId: { type: "string", required: true } },
+        async execute(input, ctx) { return api(t(ctx), "PATCH", `/pages/${input.pageId}`, { archived: true }); } });
+    rl.registerAction("page.search", { description: "Search pages",
+        inputSchema: { query: { type: "string", required: false }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const body = {};
+            if (p.query)
+                body.query = p.query;
+            if (p.limit)
+                body.page_size = p.limit;
+            const data = (await api(t(ctx), "POST", "/search", body));
+            return data.results;
+        } });
+    // ── User ────────────────────────────────────────────
+    rl.registerAction("user.get", { description: "Get a user",
+        inputSchema: { userId: { type: "string", required: true } },
+        async execute(input, ctx) { return api(t(ctx), "GET", `/users/${input.userId}`); } });
+    rl.registerAction("user.list", { description: "List all users",
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const qs = {};
+            if (input?.limit)
+                qs.page_size = input.limit;
+            const data = (await api(t(ctx), "GET", "/users", undefined, qs));
+            return data.results;
+        } });
+    rl.registerAction("user.me", { description: "Get the bot user",
+        inputSchema: {},
+        async execute(_input, ctx) { return api(t(ctx), "GET", "/users/me"); } });
+}