aiquila-mcp 0.3.22 → 0.3.24

package/dist/client/passman.js

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: MIT
+import { getNextcloudConfig } from '../tools/types.js';
+import { logger } from '../logger.js';
+import { ApiError } from './aiquila.js';
+/**
+ * Make an authenticated request to the Nextcloud Passman REST API v2.
+ *
+ * Base path: /index.php/apps/passman/api/v2
+ */
+export async function fetchPassmanAPI(endpoint, options = {}) {
+    const config = getNextcloudConfig();
+    const auth = Buffer.from(`${config.user}:${config.password}`).toString('base64');
+    let url = `${config.url}/index.php/apps/passman/api/v2${endpoint}`;
+    if (options.queryParams) {
+        const params = new URLSearchParams(options.queryParams);
+        url += `?${params.toString()}`;
+    }
+    const headers = {
+        Authorization: `Basic ${auth}`,
+        'OCS-APIRequest': 'true',
+        Accept: 'application/json',
+    };
+    let body;
+    if (options.body !== undefined) {
+        body = JSON.stringify(options.body);
+        headers['Content-Type'] = 'application/json';
+    }
+    const method = options.method ?? 'GET';
+    const t0 = Date.now();
+    const response = await fetch(url, { method, headers, body });
+    logger.trace({ method, url, status: response.status, ms: Date.now() - t0 }, '[passman] HTTP');
+    if (!response.ok) {
+        const text = await response.text();
+        throw new ApiError(response.status, response.statusText, text);
+    }
+    if (response.status === 200 &&
+        response.headers.get('content-type')?.includes('application/json')) {
+        return (await response.json());
+    }
+    return undefined;
+}

package/dist/tool-registry.js

@@ -34,12 +34,18 @@ 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';
 import { pollsTools } from './tools/apps/polls.js';
 import { formsTools } from './tools/apps/forms.js';
 import { textTools } from './tools/apps/text.js';
+import { recommendationsTools } from './tools/apps/recommendations.js';
+import { socialSharingTools } from './tools/apps/social-sharing.js';
+import { passmanTools } from './tools/apps/passman.js';
 /**
  * Single source of truth for tool-to-Nextcloud-app mapping.
  *
@@ -74,6 +80,7 @@ export const TOOL_REGISTRY = [
     { category: 'news', appIds: ['news'], tools: newsTools },
     { category: 'mail', appIds: ['mail'], tools: mailTools },
     { category: 'deck', appIds: ['deck'], tools: deckTools },
+    { category: 'passman', appIds: ['passman'], tools: passmanTools },
     { category: 'cookbook', appIds: ['cookbook'], tools: cookbookTools },
     { category: 'maps', appIds: ['maps'], tools: mapsTools },
     { category: 'photos', appIds: ['photos'], tools: photosTools },
@@ -88,6 +95,27 @@ export const TOOL_REGISTRY = [
     { 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,
+    },
+    { category: 'recommendations', appIds: ['recommendations'], tools: recommendationsTools },
+    {
+        category: 'social_sharing',
+        appIds: [
+            'socialsharing_email',
+            'socialsharing_twitter',
+            'socialsharing_facebook',
+            'socialsharing_telegram',
+            'socialsharing_whatsapp',
+            'socialsharing_bluesky',
+            'socialsharing_diaspora',
+        ],
+        tools: socialSharingTools,
+    },
 ];
 const ALL_CATEGORIES = new Set(TOOL_REGISTRY.map((e) => e.category));
 /**

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/passman.js

@@ -0,0 +1,150 @@
+// SPDX-License-Identifier: MIT
+import { z } from 'zod';
+import { fetchPassmanAPI, } from '../../client/passman.js';
+import { handleAppError } from '../error-utils.js';
+/**
+ * Nextcloud Passman App Tools (password manager)
+ * Uses the Passman REST API v2 (/index.php/apps/passman/api/v2).
+ *
+ * IMPORTANT: Passman is zero-knowledge / end-to-end encrypted. Credential
+ * secrets (password, username, url, email, description, custom fields, OTP,
+ * tags, files) are encrypted client-side (SJCL AES-256) with a vault password
+ * that never reaches the server. This integration therefore exposes vault and
+ * credential *metadata only* (notably the plaintext `label`) and cannot decrypt
+ * or return any secret value.
+ */
+const passmanStatusMap = {
+    404: 'Not found.',
+    403: 'Permission denied.',
+    400: (e) => `Bad request: ${e.responseBody}`,
+};
+const E2E_NOTE = 'Note: secret values (password, username, url, etc.) are end-to-end encrypted and cannot be retrieved by this server.';
+function formatVault(vault) {
+    const count = vault.credentials?.length ?? undefined;
+    const parts = [`guid: ${vault.guid}`];
+    if (count !== undefined)
+        parts.push(`${count} credentials`);
+    parts.push(`created: ${new Date(vault.created * 1000).toISOString()}`);
+    if (vault.last_access) {
+        parts.push(`last access: ${new Date(vault.last_access * 1000).toISOString()}`);
+    }
+    return `${vault.name} (${parts.join(', ')})`;
+}
+function hasValue(v) {
+    if (v === undefined || v === null || v === '')
+        return false;
+    if (Array.isArray(v))
+        return v.length > 0;
+    return true;
+}
+function formatCredential(cred) {
+    const flags = [];
+    if (hasValue(cred.url))
+        flags.push('has url');
+    if (hasValue(cred.tags))
+        flags.push('tagged');
+    if (cred.hidden)
+        flags.push('hidden');
+    if (cred.compromised)
+        flags.push('compromised');
+    if (cred.expire_time) {
+        flags.push(`expires: ${new Date(cred.expire_time * 1000).toISOString()}`);
+    }
+    const meta = [`guid: ${cred.guid}`, ...flags].join(', ');
+    return `[${cred.credential_id}] ${cred.label} (${meta})`;
+}
+export const listVaultsTool = {
+    name: 'passman_list_vaults',
+    description: `List all Passman password vaults. Returns name, guid, creation/last-access time and credential count. ${E2E_NOTE}`,
+    inputSchema: z.object({}),
+    handler: async () => {
+        try {
+            const vaults = await fetchPassmanAPI('/vaults');
+            if (!vaults || vaults.length === 0) {
+                return { content: [{ type: 'text', text: 'No vaults found.' }] };
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Vaults (${vaults.length}):\n\n${vaults.map(formatVault).join('\n')}\n\n${E2E_NOTE}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return handleAppError(error, 'Error listing vaults', passmanStatusMap);
+        }
+    },
+};
+export const listCredentialsTool = {
+    name: 'passman_list_credentials',
+    description: `List credentials (metadata only) in a Passman vault. Returns each credential's label, id, guid and non-secret flags. ${E2E_NOTE}`,
+    inputSchema: z.object({
+        vault_guid: z.string().describe('Vault GUID (from passman_list_vaults)'),
+    }),
+    handler: async (args) => {
+        try {
+            const vault = await fetchPassmanAPI(`/vaults/${encodeURIComponent(args.vault_guid)}`);
+            const creds = vault.credentials ?? [];
+            if (creds.length === 0) {
+                return { content: [{ type: 'text', text: 'No credentials in this vault.' }] };
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Credentials in "${vault.name}" (${creds.length}):\n\n${creds
+                            .map(formatCredential)
+                            .join('\n')}\n\n${E2E_NOTE}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return handleAppError(error, 'Error listing credentials', passmanStatusMap);
+        }
+    },
+};
+export const getCredentialInfoTool = {
+    name: 'passman_get_credential_info',
+    description: `Get non-secret metadata for a single Passman credential (label, id, timestamps, flags). ${E2E_NOTE}`,
+    inputSchema: z.object({
+        vault_guid: z.string().describe('Vault GUID (from passman_list_vaults)'),
+        credential_guid: z.string().describe('Credential GUID (from passman_list_credentials)'),
+    }),
+    handler: async (args) => {
+        try {
+            const vault = await fetchPassmanAPI(`/vaults/${encodeURIComponent(args.vault_guid)}`);
+            const cred = (vault.credentials ?? []).find((c) => c.guid === args.credential_guid);
+            if (!cred) {
+                return {
+                    content: [{ type: 'text', text: 'Credential not found in this vault.' }],
+                    isError: true,
+                };
+            }
+            const lines = [
+                `# ${cred.label}`,
+                '',
+                `ID: ${cred.credential_id}`,
+                `GUID: ${cred.guid}`,
+                `Vault: ${vault.name}`,
+                `Created: ${new Date(cred.created * 1000).toISOString()}`,
+                `Changed: ${new Date(cred.changed * 1000).toISOString()}`,
+                `Has URL: ${hasValue(cred.url)}`,
+                `Tagged: ${hasValue(cred.tags)}`,
+                `Hidden: ${Boolean(cred.hidden)}`,
+                `Compromised: ${Boolean(cred.compromised)}`,
+            ];
+            if (cred.expire_time) {
+                lines.push(`Expires: ${new Date(cred.expire_time * 1000).toISOString()}`);
+            }
+            lines.push('', E2E_NOTE);
+            return { content: [{ type: 'text', text: lines.join('\n') }] };
+        }
+        catch (error) {
+            return handleAppError(error, 'Error getting credential info', passmanStatusMap);
+        }
+    },
+};
+export const passmanTools = [listVaultsTool, listCredentialsTool, getCredentialInfoTool];

package/dist/tools/apps/recommendations.js

@@ -0,0 +1,74 @@
+// 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 formatRecommendations(items) {
+    return items
+        .map((f) => {
+        const dir = f.directory && f.directory !== '/' ? f.directory.replace(/\/$/, '') : '';
+        const path = `${dir}/${f.name}`;
+        const time = f.timestamp ? ` (${formatTime(f.timestamp)})` : '';
+        const reason = f.reason ? `\n  reason: ${f.reason}` : '';
+        return `- ${path}${time}${reason}`;
+    })
+        .join('\n');
+}
+// ---------------------------------------------------------------------------
+// list_recommendations
+// ---------------------------------------------------------------------------
+export const listRecommendationsTool = {
+    name: 'list_recommendations',
+    description: 'List files Nextcloud recommends for the configured user (e.g. recently or frequently ' +
+        'accessed, recently shared, or files in active folders), including the reason each file ' +
+        "is recommended. Respects the user's recommendations setting.",
+    inputSchema: z.object({}),
+    handler: async () => {
+        try {
+            const result = await fetchOCS('/ocs/v2.php/apps/recommendations/api/v1/recommendations');
+            const data = result.ocs.data;
+            const items = data.recommendations ?? [];
+            if (!data.enabled && items.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'Recommendations are disabled for this user.',
+                        },
+                    ],
+                };
+            }
+            if (items.length === 0) {
+                return {
+                    content: [{ type: 'text', text: 'No recommended files.' }],
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Recommended files (${items.length}):\n${formatRecommendations(items)}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error listing recommendations: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// Export
+// ---------------------------------------------------------------------------
+export const recommendationsTools = [listRecommendationsTool];

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/social-sharing.js

@@ -0,0 +1,142 @@
+// SPDX-License-Identifier: MIT
+import { z } from 'zod';
+import { fetchOCS } from '../../client/ocs.js';
+import { getNextcloudConfig } from '../types.js';
+import { handleAppError } from '../error-utils.js';
+const SHARE_TYPE_PUBLIC_LINK = 3;
+/** Default share message used by the upstream apps. */
+const DEFAULT_MESSAGE = 'I shared a file with you';
+const NETWORKS = [
+    {
+        key: 'email',
+        appId: 'socialsharing_email',
+        build: (link, msg) => `mailto:?subject=${msg}&body=${encodeURIComponent(link)}`,
+    },
+    {
+        key: 'twitter',
+        appId: 'socialsharing_twitter',
+        build: (link) => `https://twitter.com/intent/tweet?url=${encodeURIComponent(link)}`,
+    },
+    {
+        key: 'facebook',
+        appId: 'socialsharing_facebook',
+        build: (link) => `https://www.facebook.com/sharer/sharer.php?u=${encodeURIComponent(link)}`,
+    },
+    {
+        key: 'telegram',
+        appId: 'socialsharing_telegram',
+        build: (link, msg) => `https://telegram.me/share/url?url=${encodeURIComponent(link)}&text=${msg}`,
+    },
+    {
+        key: 'whatsapp',
+        appId: 'socialsharing_whatsapp',
+        build: (link, msg) => `whatsapp://send?text=${msg}:%0A%0A${encodeURIComponent(link)}`,
+    },
+    {
+        key: 'bluesky',
+        appId: 'socialsharing_bluesky',
+        build: (link, msg) => `https://bsky.app/intent/compose?text=${msg}:%0A%0A${encodeURIComponent(link)}`,
+    },
+    {
+        key: 'diaspora',
+        appId: 'socialsharing_diaspora',
+        build: (link) => `https://share.diasporafoundation.org/?url=${encodeURIComponent(link)}`,
+    },
+];
+/** Fetch the set of enabled Nextcloud app ids. */
+async function getEnabledApps() {
+    const result = await fetchOCS('/ocs/v2.php/cloud/apps', {
+        queryParams: { filter: 'enabled' },
+    });
+    return new Set(result.ocs.data.apps);
+}
+/** Resolve a public-link share by id or path. */
+async function resolvePublicShare(args) {
+    if (args.share_id !== undefined) {
+        const result = await fetchOCS(`/ocs/v2.php/apps/files_sharing/api/v1/shares/${args.share_id}`);
+        // The single-share endpoint returns an array with one entry.
+        const data = result.ocs.data;
+        const share = Array.isArray(data) ? data[0] : data;
+        if (!share)
+            throw new Error(`Share ${args.share_id} not found`);
+        return share;
+    }
+    const result = await fetchOCS('/ocs/v2.php/apps/files_sharing/api/v1/shares', {
+        queryParams: { path: args.path },
+    });
+    const link = result.ocs.data.find((s) => s.share_type === SHARE_TYPE_PUBLIC_LINK && s.token);
+    if (!link) {
+        throw new Error(`No public link share found for path "${args.path}". Create one first.`);
+    }
+    return link;
+}
+export const generateSocialShareLinksTool = {
+    name: 'generate_social_share_links',
+    description: 'Generate social-network share URLs (email, X/Twitter, Facebook, Telegram, WhatsApp, ' +
+        'Bluesky, Diaspora) for an existing Nextcloud public-link share. Only networks whose ' +
+        'socialsharing_<network> app is enabled are returned. Provide either share_id or path.',
+    inputSchema: z.object({
+        share_id: z.number().optional().describe('ID of an existing public-link share'),
+        path: z
+            .string()
+            .optional()
+            .describe('File/folder path; its public-link share is used (must already exist)'),
+        networks: z
+            .array(z.string())
+            .optional()
+            .describe('Optional filter, e.g. ["twitter","email"]. Defaults to all enabled networks.'),
+    }),
+    handler: async (args) => {
+        if (args.share_id === undefined && !args.path) {
+            return {
+                content: [{ type: 'text', text: 'Provide either share_id or path.' }],
+                isError: true,
+            };
+        }
+        try {
+            const share = await resolvePublicShare(args);
+            if (share.share_type !== SHARE_TYPE_PUBLIC_LINK || !share.token) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'The referenced share is not a public link (no shareable token).',
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const { url } = getNextcloudConfig();
+            const link = share.url || `${url}/s/${share.token}`;
+            const message = encodeURIComponent(DEFAULT_MESSAGE);
+            const filter = args.networks ? new Set(args.networks.map((n) => n.toLowerCase())) : null;
+            const enabledApps = await getEnabledApps();
+            const lines = NETWORKS.filter((n) => enabledApps.has(n.appId))
+                .filter((n) => !filter || filter.has(n.key))
+                .map((n) => `${n.key}: ${n.build(link, message)}`);
+            if (lines.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'No matching social sharing networks are available. Install/enable a ' +
+                                'socialsharing_<network> app (or adjust the networks filter).',
+                        },
+                    ],
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Social share links for ${link}:\n${lines.join('\n')}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return handleAppError(error, 'Error generating social share links');
+        }
+    },
+};
+export const socialSharingTools = [generateSocialShareLinksTool];

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.22",
+  "version": "0.3.24",
   "description": "Nextcloud MCP server — files, calendar, contacts, mail, maps, notes, tasks & 120+ more tools",
   "type": "module",
   "main": "dist/index.js",