aiquila-mcp 0.3.21 → 0.3.23

package/dist/tool-registry.js

@@ -33,6 +33,10 @@ import { talkTools } from './tools/apps/talk.js';
 import { userStatusTools } from './tools/apps/user-status.js';
 import { absenceTools } from './tools/apps/absence.js';
 import { notificationsTools } from './tools/apps/notifications.js';
+import { activityTools } from './tools/apps/activity.js';
+import { announcementTools } from './tools/apps/announcements.js';
+import { registrationTools } from './tools/apps/registration.js';
+import { termsOfServiceTools } from './tools/apps/terms-of-service.js';
 import { trashTools } from './tools/apps/trash.js';
 import { versionsTools } from './tools/apps/versions.js';
 import { projectsTools } from './tools/apps/projects.js';
@@ -86,6 +90,14 @@ export const TOOL_REGISTRY = [
     { category: 'translate', appIds: ['text_translate', 'translate'], tools: translateTools },
     { category: 'user_status', appIds: ['user_status'], tools: userStatusTools },
     { category: 'notifications', appIds: ['notifications'], tools: notificationsTools },
+    { category: 'activity', appIds: ['activity'], tools: activityTools },
+    { category: 'announcements', appIds: ['announcementcenter'], tools: announcementTools },
+    { category: 'registration', appIds: ['registration'], tools: registrationTools },
+    {
+        category: 'terms_of_service',
+        appIds: ['terms_of_service'],
+        tools: termsOfServiceTools,
+    },
 ];
 const ALL_CATEGORIES = new Set(TOOL_REGISTRY.map((e) => e.category));
 /**

package/dist/tools/apps/activity.js

@@ -0,0 +1,127 @@
+// SPDX-License-Identifier: MIT
+import { z } from 'zod';
+import { fetchOCS } from '../../client/ocs.js';
+function formatActivities(activities) {
+    return activities
+        .map((a) => {
+        const time = a.datetime ? ` (${a.datetime})` : '';
+        const msg = a.message ? `\n  ${a.message}` : '';
+        return `- [${a.app}] ${a.subject}${time}${msg}`;
+    })
+        .join('\n');
+}
+// ---------------------------------------------------------------------------
+// list_activity
+// ---------------------------------------------------------------------------
+export const listActivityTool = {
+    name: 'list_activity',
+    description: 'List recent entries from the Nextcloud activity feed (file changes, shares, ' +
+        'comments, calendar/contact edits, etc.) for the current user.',
+    inputSchema: z.object({
+        filter: z
+            .enum(['all', 'self', 'by'])
+            .optional()
+            .describe("Which feed to read: 'all' (default), 'self' (your own actions), or 'by' (others' actions)"),
+        limit: z.number().optional().describe('Maximum number of activities to return (default 50)'),
+        since: z
+            .number()
+            .optional()
+            .describe('Return activities after this activity_id (for pagination)'),
+        sort: z
+            .enum(['asc', 'desc'])
+            .optional()
+            .describe("Sort order by time: 'desc' (newest first, default) or 'asc'"),
+    }),
+    handler: async (args) => {
+        try {
+            const filter = args.filter ?? 'all';
+            const queryParams = {
+                limit: String(args.limit ?? 50),
+                sort: args.sort ?? 'desc',
+            };
+            if (args.since !== undefined)
+                queryParams.since = String(args.since);
+            const result = await fetchOCS(`/ocs/v2.php/apps/activity/api/v2/activity/${filter}`, { queryParams });
+            const activities = result.ocs.data;
+            if (activities.length === 0) {
+                return {
+                    content: [{ type: 'text', text: 'No activity.' }],
+                };
+            }
+            const lastId = activities[activities.length - 1].activity_id;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Activity (${activities.length}):\n${formatActivities(activities)}\n\n` +
+                            `Last activity_id: ${lastId} (pass as 'since' to page further).`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error listing activity: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// get_object_activity
+// ---------------------------------------------------------------------------
+export const getObjectActivityTool = {
+    name: 'get_object_activity',
+    description: 'List the activity history for a single object, e.g. one file. Use object_type ' +
+        "'files' with a file ID to see what happened to that file.",
+    inputSchema: z.object({
+        object_type: z.string().optional().describe("The object type to filter by (default 'files')"),
+        object_id: z.string().describe('The object ID (e.g. the Nextcloud file ID)'),
+        limit: z.number().optional().describe('Maximum number of activities to return (default 50)'),
+    }),
+    handler: async (args) => {
+        try {
+            const result = await fetchOCS('/ocs/v2.php/apps/activity/api/v2/activity/filter', {
+                queryParams: {
+                    object_type: args.object_type ?? 'files',
+                    object_id: args.object_id,
+                    limit: String(args.limit ?? 50),
+                },
+            });
+            const activities = result.ocs.data;
+            if (activities.length === 0) {
+                return {
+                    content: [{ type: 'text', text: 'No activity for this object.' }],
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Activity (${activities.length}):\n${formatActivities(activities)}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error getting object activity: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// Export
+// ---------------------------------------------------------------------------
+export const activityTools = [listActivityTool, getObjectActivityTool];

package/dist/tools/apps/announcements.js

@@ -0,0 +1,178 @@
+// SPDX-License-Identifier: MIT
+import { z } from 'zod';
+import { fetchOCS } from '../../client/ocs.js';
+function formatTime(ts) {
+    if (!ts)
+        return '';
+    return new Date(ts * 1000).toISOString();
+}
+function formatAnnouncements(items) {
+    return items
+        .map((a) => {
+        const time = a.time ? ` (${formatTime(a.time)})` : '';
+        const schedule = a.schedule_time ? `\n  scheduled: ${formatTime(a.schedule_time)}` : '';
+        const del = a.delete_time ? `\n  deletes: ${formatTime(a.delete_time)}` : '';
+        return `- #${a.id} [${a.author}] ${a.subject}${time}${schedule}${del}`;
+    })
+        .join('\n');
+}
+// ---------------------------------------------------------------------------
+// list_announcements
+// ---------------------------------------------------------------------------
+export const listAnnouncementsTool = {
+    name: 'list_announcements',
+    description: 'List announcements from the Nextcloud Announcement Center (org-wide notices such as ' +
+        'maintenance windows, events, or news). Returns newest first.',
+    inputSchema: z.object({
+        offset: z
+            .number()
+            .optional()
+            .describe('Return announcements before this offset (for pagination, default 0)'),
+    }),
+    handler: async (args) => {
+        try {
+            const queryParams = {
+                offset: String(args.offset ?? 0),
+            };
+            const result = await fetchOCS('/ocs/v2.php/apps/announcementcenter/api/v1/announcements', { queryParams });
+            const items = result.ocs.data;
+            if (items.length === 0) {
+                return {
+                    content: [{ type: 'text', text: 'No announcements.' }],
+                };
+            }
+            const lastId = items[items.length - 1].id;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Announcements (${items.length}):\n${formatAnnouncements(items)}\n\n` +
+                            `Last id: ${lastId} (pass as 'offset' to page further).`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error listing announcements: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// create_announcement
+// ---------------------------------------------------------------------------
+export const createAnnouncementTool = {
+    name: 'create_announcement',
+    description: 'Create a new announcement in the Announcement Center. This is visible to all or ' +
+        'selected groups and can trigger notifications/emails — use deliberately. Requires the ' +
+        'configured Nextcloud user to be an admin.',
+    inputSchema: z.object({
+        subject: z.string().describe('The announcement title (kept short)'),
+        message: z.string().describe('The announcement body (Markdown supported)'),
+        plainMessage: z
+            .string()
+            .optional()
+            .describe('Plain-text version of the message (defaults to message)'),
+        groups: z
+            .array(z.string())
+            .optional()
+            .describe("Group IDs to target, or ['everyone'] for all users (default)"),
+        activities: z.boolean().optional().describe('Publish to the activity feed (default true)'),
+        notifications: z.boolean().optional().describe('Send notifications (default true)'),
+        emails: z.boolean().optional().describe('Send emails (default false)'),
+        comments: z.boolean().optional().describe('Allow comments (default true)'),
+        scheduleTime: z
+            .number()
+            .optional()
+            .describe('Unix timestamp (seconds) to publish the announcement later'),
+        deleteTime: z
+            .number()
+            .optional()
+            .describe('Unix timestamp (seconds) to automatically delete the announcement'),
+    }),
+    handler: async (args) => {
+        try {
+            const jsonBody = {
+                subject: args.subject,
+                message: args.message,
+                plainMessage: args.plainMessage ?? args.message,
+                groups: args.groups ?? ['everyone'],
+                activities: args.activities ?? true,
+                notifications: args.notifications ?? true,
+                emails: args.emails ?? false,
+                comments: args.comments ?? true,
+            };
+            if (args.scheduleTime !== undefined)
+                jsonBody.scheduleTime = args.scheduleTime;
+            if (args.deleteTime !== undefined)
+                jsonBody.deleteTime = args.deleteTime;
+            const result = await fetchOCS('/ocs/v2.php/apps/announcementcenter/api/v1/announcements', { method: 'POST', jsonBody });
+            const created = result.ocs.data;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Created announcement #${created.id}: "${created.subject}"`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error creating announcement: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// delete_announcement
+// ---------------------------------------------------------------------------
+export const deleteAnnouncementTool = {
+    name: 'delete_announcement',
+    description: 'Delete an announcement by its ID. Requires the configured Nextcloud user to be an admin.',
+    inputSchema: z.object({
+        id: z.number().describe('The announcement ID to delete'),
+    }),
+    handler: async (args) => {
+        try {
+            await fetchOCS(`/ocs/v2.php/apps/announcementcenter/api/v1/announcements/${args.id}`, {
+                method: 'DELETE',
+            });
+            return {
+                content: [{ type: 'text', text: `Deleted announcement #${args.id}.` }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error deleting announcement: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// Export
+// ---------------------------------------------------------------------------
+export const announcementTools = [
+    listAnnouncementsTool,
+    createAnnouncementTool,
+    deleteAnnouncementTool,
+];

package/dist/tools/apps/registration.js

@@ -0,0 +1,164 @@
+// SPDX-License-Identifier: MIT
+import { z } from 'zod';
+import { fetchOCS } from '../../client/ocs.js';
+/**
+ * Nextcloud Registration Tools
+ *
+ * The Registration app (https://github.com/nextcloud/registration) lets visitors
+ * self-register accounts via an email-verification flow. It exposes no API of its
+ * own — all admin behaviour is driven by app config keys stored under the
+ * `registration` app id. These tools read and write those keys through core's
+ * provisioning_api appconfig OCS endpoints.
+ *
+ * Pending registrations are not exposed by any API. When `admin_approval_required`
+ * is enabled, registrants become disabled Nextcloud users — approve or reject them
+ * with the standard user tools (enable_user / delete_user).
+ */
+const APPCONFIG_BASE = '/ocs/v2.php/apps/provisioning_api/api/v1/config/apps/registration';
+/** Known Registration app config keys, with short descriptions. */
+const REGISTRATION_KEYS = {
+    allowed_domains: 'Email domains allowed (or, with domains_is_blocklist, blocked) for registration (JSON array string)',
+    domains_is_blocklist: 'Treat allowed_domains as a blocklist instead of an allowlist (yes/no)',
+    show_domains: 'Show the email domain list to users (yes/no)',
+    admin_approval_required: 'Newly registered users must be validated by an admin (yes/no)',
+    registered_user_group: 'Group id newly registered users are added to',
+    email_is_optional: 'Email address is optional during registration (yes/no)',
+    email_is_login: 'Force the email address as the user id / login (yes/no)',
+    disable_email_verification: 'Skip the email verification step (yes/no)',
+    email_verification_hint: 'Text embedded in the verification email',
+    additional_hint: 'Text displayed on the account creation form',
+    username_policy_regex: 'Optional regex the chosen username must match',
+    show_fullname: 'Show the full name field on the registration form (yes/no)',
+    enforce_fullname: 'Make the full name field mandatory (yes/no)',
+    show_phone: 'Show the phone field on the registration form (yes/no)',
+    enforce_phone: 'Make the phone field mandatory (yes/no)',
+};
+const KNOWN_KEYS = Object.keys(REGISTRATION_KEYS);
+// ---------------------------------------------------------------------------
+// get_registration_settings
+// ---------------------------------------------------------------------------
+export const getRegistrationSettingsTool = {
+    name: 'get_registration_settings',
+    description: 'Read the Nextcloud Registration app settings (self-service signup configuration), such as ' +
+        'allowed email domains, whether admin approval is required, and the default group for new ' +
+        'users. Requires the configured Nextcloud user to be an admin.',
+    inputSchema: z.object({}),
+    handler: async () => {
+        try {
+            const entries = await Promise.all(KNOWN_KEYS.map(async (key) => {
+                const result = await fetchOCS(`${APPCONFIG_BASE}/${key}`);
+                return [key, result.ocs.data];
+            }));
+            const text = entries
+                .map(([key, value]) => `- ${key}: ${value === '' ? '(default)' : value}`)
+                .join('\n');
+            return {
+                content: [{ type: 'text', text: `Registration settings:\n${text}` }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error reading registration settings: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// update_registration_settings
+// ---------------------------------------------------------------------------
+export const updateRegistrationSettingsTool = {
+    name: 'update_registration_settings',
+    description: 'Update one or more Nextcloud Registration app settings. Boolean settings use the strings ' +
+        "'yes'/'no'; allowed_domains takes a JSON array string (e.g. '[\"example.com\"]'). Requires " +
+        'the configured Nextcloud user to be an admin.',
+    inputSchema: z.object({
+        settings: z
+            .array(z.object({
+            key: z
+                .enum(KNOWN_KEYS)
+                .describe('The Registration config key to set'),
+            value: z.string().describe('The value to store (boolean keys: "yes"/"no")'),
+        }))
+            .min(1)
+            .describe('One or more key/value pairs to update'),
+    }),
+    handler: async (args) => {
+        try {
+            const updated = [];
+            for (const { key, value } of args.settings) {
+                await fetchOCS(`${APPCONFIG_BASE}/${key}`, {
+                    method: 'POST',
+                    body: { value },
+                });
+                updated.push(`${key} = ${value}`);
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Updated registration settings:\n${updated.map((u) => `- ${u}`).join('\n')}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error updating registration settings: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// reset_registration_setting
+// ---------------------------------------------------------------------------
+export const resetRegistrationSettingTool = {
+    name: 'reset_registration_setting',
+    description: 'Reset a Nextcloud Registration app setting to its default by deleting the stored value. ' +
+        'Requires the configured Nextcloud user to be an admin.',
+    inputSchema: z.object({
+        key: z
+            .enum(KNOWN_KEYS)
+            .describe('The Registration config key to reset to its default'),
+    }),
+    handler: async (args) => {
+        try {
+            await fetchOCS(`${APPCONFIG_BASE}/${args.key}`, { method: 'DELETE' });
+            return {
+                content: [
+                    { type: 'text', text: `Reset registration setting '${args.key}' to default.` },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error resetting registration setting: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// Export
+// ---------------------------------------------------------------------------
+export const registrationTools = [
+    getRegistrationSettingsTool,
+    updateRegistrationSettingsTool,
+    resetRegistrationSettingTool,
+];

package/dist/tools/apps/terms-of-service.js

@@ -0,0 +1,254 @@
+// SPDX-License-Identifier: MIT
+import { z } from 'zod';
+import { fetchOCS } from '../../client/ocs.js';
+/**
+ * Nextcloud Terms of Service Tools
+ *
+ * The Terms of Service app (https://github.com/nextcloud/terms_of_service) lets admins
+ * publish per-country / per-language terms that users must accept. It exposes its own OCS
+ * API under `/ocs/v2.php/apps/terms_of_service`, so most tools call those endpoints
+ * directly.
+ *
+ * Two enforcement flags (`tos_for_users`, `tos_on_public_shares`) are plain app config
+ * keys: they are read via the admin form endpoint and written through core's
+ * provisioning_api appconfig endpoints.
+ */
+const OCS_BASE = '/ocs/v2.php/apps/terms_of_service';
+const APPCONFIG_BASE = '/ocs/v2.php/apps/provisioning_api/api/v1/config/apps/terms_of_service';
+function preview(body) {
+    const oneLine = body.replace(/\s+/g, ' ').trim();
+    return oneLine.length > 80 ? `${oneLine.slice(0, 80)}…` : oneLine;
+}
+// ---------------------------------------------------------------------------
+// get_terms_of_service
+// ---------------------------------------------------------------------------
+export const getTermsOfServiceTool = {
+    name: 'get_terms_of_service',
+    description: 'Read the Nextcloud Terms of Service admin configuration: all published terms (by ' +
+        'country/language), the enforcement settings (tos_for_users, tos_on_public_shares), and ' +
+        'the valid country and language codes that can be used when setting terms. Requires the ' +
+        'configured Nextcloud user to be an admin.',
+    inputSchema: z.object({}),
+    handler: async () => {
+        try {
+            const result = await fetchOCS(`${OCS_BASE}/terms/admin`);
+            const data = result.ocs.data;
+            const termsText = data.terms.length === 0
+                ? '(none)'
+                : data.terms
+                    .map((t) => `- #${t.id} [${t.countryCode}/${t.languageCode}] ${preview(t.body)}`)
+                    .join('\n');
+            const settings = [
+                `- tos_for_users: ${data.tos_for_users}`,
+                `- tos_on_public_shares: ${data.tos_on_public_shares}`,
+            ].join('\n');
+            const countries = Object.keys(data.countries).join(', ');
+            const languages = Object.keys(data.languages).join(', ');
+            const text = `Terms of Service:\n${termsText}\n\n` +
+                `Settings:\n${settings}\n\n` +
+                `Valid country codes (use "--" for global): ${countries}\n` +
+                `Valid language codes: ${languages}`;
+            return {
+                content: [{ type: 'text', text }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error reading terms of service: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// set_terms_of_service
+// ---------------------------------------------------------------------------
+export const setTermsOfServiceTool = {
+    name: 'set_terms_of_service',
+    description: 'Create or update the terms of service for a given country/language pair. If terms ' +
+        'already exist for that pair they are replaced, otherwise new terms are created. Use ' +
+        'get_terms_of_service to discover valid country/language codes; an invalid code returns ' +
+        'an error (HTTP 417). Requires the configured Nextcloud user to be an admin.',
+    inputSchema: z.object({
+        countryCode: z
+            .string()
+            .default('--')
+            .describe('2-letter region code, or "--" for global (default)'),
+        languageCode: z.string().describe('2-letter language code (e.g. "en")'),
+        body: z.string().describe('The terms text (markdown: headers, formatting, lists, links)'),
+    }),
+    handler: async (args) => {
+        const countryCode = args.countryCode ?? '--';
+        try {
+            const result = await fetchOCS(`${OCS_BASE}/terms`, {
+                method: 'POST',
+                body: {
+                    countryCode,
+                    languageCode: args.languageCode,
+                    body: args.body,
+                },
+            });
+            const t = result.ocs.data;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Saved terms #${t.id} for [${t.countryCode}/${t.languageCode}].`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error saving terms of service: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// delete_terms_of_service
+// ---------------------------------------------------------------------------
+export const deleteTermsOfServiceTool = {
+    name: 'delete_terms_of_service',
+    description: 'Delete a single terms of service entry by its id (see get_terms_of_service). Requires ' +
+        'the configured Nextcloud user to be an admin.',
+    inputSchema: z.object({
+        id: z.number().describe('The terms id to delete'),
+    }),
+    handler: async (args) => {
+        try {
+            await fetchOCS(`${OCS_BASE}/terms/${args.id}`, { method: 'DELETE' });
+            return {
+                content: [{ type: 'text', text: `Deleted terms #${args.id}.` }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error deleting terms of service: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// reset_terms_signatures
+// ---------------------------------------------------------------------------
+export const resetTermsSignaturesTool = {
+    name: 'reset_terms_signatures',
+    description: "Reset ALL users' terms of service signatures org-wide, forcing every user to accept " +
+        'the terms again on next login. This is destructive and cannot be undone. Requires the ' +
+        'configured Nextcloud user to be an admin.',
+    inputSchema: z.object({}),
+    handler: async () => {
+        try {
+            await fetchOCS(`${OCS_BASE}/sign`, { method: 'DELETE' });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Reset all terms of service signatures. All users must accept the terms again.',
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error resetting terms signatures: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// update_terms_settings
+// ---------------------------------------------------------------------------
+export const updateTermsSettingsTool = {
+    name: 'update_terms_settings',
+    description: 'Update the Terms of Service enforcement settings: whether logged-in users must accept ' +
+        'the terms (tos_for_users) and whether the terms apply to public shares ' +
+        '(tos_on_public_shares). Requires the configured Nextcloud user to be an admin.',
+    inputSchema: z.object({
+        tosForUsers: z.boolean().optional().describe('Require logged-in users to accept the terms'),
+        tosOnPublicShares: z.boolean().optional().describe('Apply the terms to public shares'),
+    }),
+    handler: async (args) => {
+        const updates = [];
+        if (args.tosForUsers !== undefined)
+            updates.push(['tos_for_users', args.tosForUsers]);
+        if (args.tosOnPublicShares !== undefined) {
+            updates.push(['tos_on_public_shares', args.tosOnPublicShares]);
+        }
+        if (updates.length === 0) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'No settings provided. Specify tosForUsers and/or tosOnPublicShares.',
+                    },
+                ],
+                isError: true,
+            };
+        }
+        try {
+            const applied = [];
+            for (const [key, enabled] of updates) {
+                const value = enabled ? 'yes' : 'no';
+                await fetchOCS(`${APPCONFIG_BASE}/${key}`, {
+                    method: 'POST',
+                    body: { value },
+                });
+                applied.push(`${key} = ${value}`);
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Updated terms of service settings:\n${applied.map((u) => `- ${u}`).join('\n')}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error updating terms settings: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// Export
+// ---------------------------------------------------------------------------
+export const termsOfServiceTools = [
+    getTermsOfServiceTool,
+    setTermsOfServiceTool,
+    deleteTermsOfServiceTool,
+    resetTermsSignaturesTool,
+    updateTermsSettingsTool,
+];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiquila-mcp",
-  "version": "0.3.21",
+  "version": "0.3.23",
   "description": "Nextcloud MCP server — files, calendar, contacts, mail, maps, notes, tasks & 120+ more tools",
   "type": "module",
   "main": "dist/index.js",