aiquila-mcp 0.2.6 → 0.2.7

package/dist/server.js

@@ -23,6 +23,8 @@ import { mailTools } from './tools/apps/mail.js';
 import { bookmarksTools } from './tools/apps/bookmarks.js';
 import { mapsTools } from './tools/apps/maps.js';
 import { assistantTools } from './tools/apps/assistant.js';
+import { translateTools } from './tools/apps/translate.js';
+import { talkTools } from './tools/apps/talk.js';
 const SERVER_NAME = 'aiquila';
 const _require = createRequire(import.meta.url);
 export const SERVER_VERSION = _require('../package.json').version;
@@ -47,6 +49,8 @@ const allToolSets = [
     tagsTools,
     searchTools,
     assistantTools,
+    translateTools,
+    talkTools,
 ];
 /**
  * Create a fully-configured McpServer with all tools registered.

package/dist/tools/apps/mail.js

@@ -109,7 +109,7 @@ const listMailboxesTool = {
     },
 };
 const listMessagesTool = {
-    name: 'list_messages',
+    name: 'mail_list_messages',
     description: 'List email messages in a Nextcloud Mail mailbox. Supports pagination via cursor. Returns subject, sender, date, and message IDs.',
     inputSchema: z.object({
         mailboxId: z.number().describe('The mailbox ID (from list_mailboxes)'),
@@ -174,7 +174,7 @@ const listMessagesTool = {
     },
 };
 const readMessageTool = {
-    name: 'read_message',
+    name: 'mail_read_message',
     description: 'Read the full content of an email message by ID. Returns headers, body text, and attachment list.',
     inputSchema: z.object({
         messageId: z.number().describe('The message ID (from list_messages)'),
@@ -227,7 +227,7 @@ const readMessageTool = {
     },
 };
 const sendMessageTool = {
-    name: 'send_message',
+    name: 'mail_send_message',
     description: 'Send an email message through Nextcloud Mail. Requires an account ID and recipient addresses.',
     inputSchema: z.object({
         accountId: z.number().describe('The mail account ID to send from (from list_mail_accounts)'),
@@ -290,7 +290,7 @@ const sendMessageTool = {
     },
 };
 const deleteMessageTool = {
-    name: 'delete_message',
+    name: 'mail_delete_message',
     description: 'Delete an email message by ID. This typically moves it to trash.',
     inputSchema: z.object({
         messageId: z.number().describe('The message ID to delete'),
@@ -321,7 +321,7 @@ const deleteMessageTool = {
     },
 };
 const moveMessageTool = {
-    name: 'move_message',
+    name: 'mail_move_message',
     description: 'Move an email message to a different mailbox/folder.',
     inputSchema: z.object({
         messageId: z.number().describe('The message ID to move'),
@@ -359,7 +359,7 @@ const moveMessageTool = {
     },
 };
 const setMessageFlagsTool = {
-    name: 'set_message_flags',
+    name: 'mail_set_message_flags',
     description: 'Set flags on an email message (mark as read/unread, star/unstar, mark as important or junk).',
     inputSchema: z.object({
         messageId: z.number().describe('The message ID'),

package/dist/tools/apps/talk.js

@@ -0,0 +1,399 @@
+import { z } from 'zod';
+import { fetchOCS } from '../../client/ocs.js';
+/**
+ * Nextcloud Talk (Spreed) Tools
+ *
+ * Bridges MCP to Nextcloud's Talk API for managing conversations,
+ * messages, participants, polls, and reactions.
+ */
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const API_V4 = '/ocs/v2.php/apps/spreed/api/v4';
+const API_V1 = '/ocs/v2.php/apps/spreed/api/v1';
+const CONVERSATION_TYPE_LABELS = {
+    1: 'one-on-one',
+    2: 'group',
+    3: 'public',
+    4: 'changelog',
+    5: 'former one-on-one',
+};
+const PARTICIPANT_TYPE_LABELS = {
+    1: 'owner',
+    2: 'moderator',
+    3: 'user',
+    4: 'guest',
+    5: 'public link user',
+    6: 'guest moderator',
+};
+const ROOM_TYPE_MAP = {
+    'one-on-one': 1,
+    group: 2,
+    public: 3,
+};
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function resolveRichMessage(message, params) {
+    if (!params)
+        return message;
+    let resolved = message;
+    for (const [key, param] of Object.entries(params)) {
+        resolved = resolved.replace(`{${key}}`, param.name ?? param.id);
+    }
+    return resolved;
+}
+function formatTimestamp(ts) {
+    const d = new Date(ts * 1000);
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+function text(t) {
+    return { content: [{ type: 'text', text: t }] };
+}
+function error(msg) {
+    return { content: [{ type: 'text', text: msg }], isError: true };
+}
+function wrapError(action, err) {
+    return error(`Error ${action}: ${err instanceof Error ? err.message : String(err)}`);
+}
+// ---------------------------------------------------------------------------
+// list_conversations
+// ---------------------------------------------------------------------------
+export const listConversationsTool = {
+    name: 'talk_list_conversations',
+    description: 'List all Talk conversations the user has access to. Returns conversation tokens, names, types, and unread message counts.',
+    inputSchema: z.object({
+        includeStatus: z
+            .boolean()
+            .optional()
+            .describe('Include user status information (default false)'),
+    }),
+    handler: async (args) => {
+        try {
+            const queryParams = {};
+            if (args.includeStatus)
+                queryParams.includeStatus = 'true';
+            const data = await fetchOCS(`${API_V4}/room`, { queryParams });
+            const rooms = data.ocs.data ?? [];
+            if (rooms.length === 0)
+                return text('No conversations found.');
+            const lines = rooms.map((r) => {
+                const type = CONVERSATION_TYPE_LABELS[r.type] ?? `type-${r.type}`;
+                const last = r.lastActivity ? formatTimestamp(r.lastActivity) : 'never';
+                let line = `[${r.token}] ${r.displayName || r.name} (${type}, unread: ${r.unreadMessages}) — last: ${last}`;
+                if (args.includeStatus && r.status) {
+                    line += ` — status: ${r.status}${r.statusMessage ? ` "${r.statusMessage}"` : ''}`;
+                }
+                return line;
+            });
+            return text(lines.join('\n'));
+        }
+        catch (err) {
+            return wrapError('listing conversations', err);
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// list_messages
+// ---------------------------------------------------------------------------
+export const listMessagesTool = {
+    name: 'talk_list_messages',
+    description: 'List recent messages in a Talk conversation. Returns message content with timestamps and authors.',
+    inputSchema: z.object({
+        token: z.string().describe('Conversation token (from list_conversations)'),
+        limit: z.number().optional().describe('Number of messages to retrieve (default 50, max 200)'),
+        lastKnownMessageId: z
+            .number()
+            .optional()
+            .describe('Message ID to start from for pagination (returns messages before this ID)'),
+        includeSystemMessages: z
+            .boolean()
+            .optional()
+            .describe('Include system messages like join/leave notifications (default false)'),
+    }),
+    handler: async (args) => {
+        try {
+            const queryParams = {
+                lookIntoFuture: '0',
+                limit: String(Math.min(args.limit ?? 50, 200)),
+            };
+            if (args.lastKnownMessageId) {
+                queryParams.lastKnownMessageId = String(args.lastKnownMessageId);
+            }
+            const data = await fetchOCS(`${API_V4}/chat/${args.token}`, { queryParams });
+            let messages = data.ocs.data ?? [];
+            if (!args.includeSystemMessages) {
+                messages = messages.filter((m) => !m.systemMessage);
+            }
+            if (messages.length === 0)
+                return text('No messages found.');
+            const lines = messages.map((m) => {
+                const ts = formatTimestamp(m.timestamp);
+                const resolved = resolveRichMessage(m.message, m.messageParameters);
+                return `[${ts}] ${m.actorDisplayName}: ${resolved}`;
+            });
+            return text(lines.join('\n'));
+        }
+        catch (err) {
+            return wrapError('listing messages', err);
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// send_message
+// ---------------------------------------------------------------------------
+export const sendMessageTool = {
+    name: 'talk_send_message',
+    description: 'Send a message to a Talk conversation. Supports replies and silent messages that do not trigger notifications.',
+    inputSchema: z.object({
+        token: z.string().describe('Conversation token'),
+        message: z.string().describe('Message text to send'),
+        replyTo: z.number().optional().describe('Message ID to reply to'),
+        silent: z
+            .boolean()
+            .optional()
+            .describe('Send without triggering notifications (default false)'),
+    }),
+    handler: async (args) => {
+        try {
+            const body = { message: args.message };
+            if (args.replyTo !== undefined)
+                body.replyTo = String(args.replyTo);
+            if (args.silent)
+                body.silent = 'true';
+            const data = await fetchOCS(`${API_V4}/chat/${args.token}`, {
+                method: 'POST',
+                body,
+            });
+            const msg = data.ocs.data;
+            return text(`Message sent (ID: ${msg.id}) at ${formatTimestamp(msg.timestamp)}: ${resolveRichMessage(msg.message, msg.messageParameters)}`);
+        }
+        catch (err) {
+            return wrapError('sending message', err);
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// create_conversation
+// ---------------------------------------------------------------------------
+export const createConversationTool = {
+    name: 'talk_create_conversation',
+    description: 'Create a new Talk conversation. One-on-one requires an invite user, group/public require a name.',
+    inputSchema: z.object({
+        roomType: z.enum(['one-on-one', 'group', 'public']).describe('Type of conversation to create'),
+        roomName: z
+            .string()
+            .optional()
+            .describe('Name for the conversation (required for group and public)'),
+        invite: z.string().optional().describe('User ID to invite (required for one-on-one)'),
+    }),
+    handler: async (args) => {
+        if (args.roomType === 'one-on-one' && !args.invite) {
+            return error('invite is required for one-on-one conversations.');
+        }
+        if ((args.roomType === 'group' || args.roomType === 'public') && !args.roomName) {
+            return error('roomName is required for group and public conversations.');
+        }
+        try {
+            const body = {
+                roomType: String(ROOM_TYPE_MAP[args.roomType]),
+            };
+            if (args.roomName)
+                body.roomName = args.roomName;
+            if (args.invite)
+                body.invite = args.invite;
+            const data = await fetchOCS(`${API_V4}/room`, {
+                method: 'POST',
+                body,
+            });
+            const room = data.ocs.data;
+            const type = CONVERSATION_TYPE_LABELS[room.type] ?? `type-${room.type}`;
+            return text(`Conversation created: [${room.token}] ${room.displayName || room.name} (${type})`);
+        }
+        catch (err) {
+            return wrapError('creating conversation', err);
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// list_participants
+// ---------------------------------------------------------------------------
+export const listParticipantsTool = {
+    name: 'talk_list_participants',
+    description: 'List all participants in a Talk conversation with their roles.',
+    inputSchema: z.object({
+        token: z.string().describe('Conversation token'),
+    }),
+    handler: async (args) => {
+        try {
+            const data = await fetchOCS(`${API_V4}/room/${args.token}/participants`);
+            const participants = data.ocs.data ?? [];
+            if (participants.length === 0)
+                return text('No participants found.');
+            const lines = participants.map((p) => {
+                const role = PARTICIPANT_TYPE_LABELS[p.participantType] ?? `type-${p.participantType}`;
+                return `${p.actorId} (${p.displayName}) — ${role}, attendeeId: ${p.attendeeId}`;
+            });
+            return text(lines.join('\n'));
+        }
+        catch (err) {
+            return wrapError('listing participants', err);
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// add_participant
+// ---------------------------------------------------------------------------
+export const addParticipantTool = {
+    name: 'talk_add_participant',
+    description: 'Add a user, group, or email participant to a Talk conversation.',
+    inputSchema: z.object({
+        token: z.string().describe('Conversation token'),
+        newParticipant: z.string().describe('User ID, group ID, or email address to add'),
+        source: z
+            .enum(['users', 'groups', 'emails'])
+            .optional()
+            .describe("Participant source type (default 'users')"),
+    }),
+    handler: async (args) => {
+        try {
+            const body = { newParticipant: args.newParticipant };
+            if (args.source)
+                body.source = args.source;
+            await fetchOCS(`${API_V4}/room/${args.token}/participants`, {
+                method: 'POST',
+                body,
+            });
+            return text(`Participant "${args.newParticipant}" added to conversation ${args.token}.`);
+        }
+        catch (err) {
+            return wrapError('adding participant', err);
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// remove_participant
+// ---------------------------------------------------------------------------
+export const removeParticipantTool = {
+    name: 'talk_remove_participant',
+    description: 'Remove a participant from a Talk conversation by their attendee ID (from list_participants).',
+    inputSchema: z.object({
+        token: z.string().describe('Conversation token'),
+        attendeeId: z.number().describe('Attendee ID of the participant to remove'),
+    }),
+    handler: async (args) => {
+        try {
+            await fetchOCS(`${API_V4}/room/${args.token}/attendees`, {
+                method: 'DELETE',
+                body: { attendeeId: String(args.attendeeId) },
+            });
+            return text(`Participant (attendeeId: ${args.attendeeId}) removed from conversation ${args.token}.`);
+        }
+        catch (err) {
+            return wrapError('removing participant', err);
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// delete_message
+// ---------------------------------------------------------------------------
+export const deleteMessageTool = {
+    name: 'talk_delete_message',
+    description: 'Delete a message from a Talk conversation.',
+    inputSchema: z.object({
+        token: z.string().describe('Conversation token'),
+        messageId: z.number().describe('ID of the message to delete'),
+    }),
+    handler: async (args) => {
+        try {
+            await fetchOCS(`${API_V4}/chat/${args.token}/${args.messageId}`, {
+                method: 'DELETE',
+            });
+            return text(`Message ${args.messageId} deleted from conversation ${args.token}.`);
+        }
+        catch (err) {
+            return wrapError('deleting message', err);
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// create_poll
+// ---------------------------------------------------------------------------
+export const createPollTool = {
+    name: 'talk_create_poll',
+    description: 'Create a poll in a Talk conversation. Requires at least 2 options.',
+    inputSchema: z.object({
+        token: z.string().describe('Conversation token'),
+        question: z.string().describe('Poll question'),
+        options: z.array(z.string()).min(2).describe('Poll options (minimum 2)'),
+        resultMode: z
+            .enum(['public', 'hidden'])
+            .optional()
+            .describe("Result visibility: 'public' (default) or 'hidden' until closed"),
+        maxVotes: z
+            .number()
+            .optional()
+            .describe('Maximum number of votes per participant (0 = unlimited, default 1)'),
+    }),
+    handler: async (args) => {
+        if (args.options.length < 2) {
+            return error('A poll requires at least 2 options.');
+        }
+        try {
+            const jsonBody = {
+                question: args.question,
+                options: args.options,
+                resultMode: args.resultMode === 'hidden' ? 1 : 0,
+                maxVotes: args.maxVotes ?? 1,
+            };
+            await fetchOCS(`${API_V1}/poll/${args.token}`, {
+                method: 'POST',
+                jsonBody,
+            });
+            return text(`Poll created in conversation ${args.token}: "${args.question}" with ${args.options.length} options.`);
+        }
+        catch (err) {
+            return wrapError('creating poll', err);
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// react_to_message
+// ---------------------------------------------------------------------------
+export const reactToMessageTool = {
+    name: 'talk_react_to_message',
+    description: 'Add an emoji reaction to a message in a Talk conversation.',
+    inputSchema: z.object({
+        token: z.string().describe('Conversation token'),
+        messageId: z.number().describe('ID of the message to react to'),
+        reaction: z.string().describe("Emoji reaction (e.g. '👍', '❤️', '🎉')"),
+    }),
+    handler: async (args) => {
+        try {
+            await fetchOCS(`${API_V1}/reaction/${args.token}/${args.messageId}`, {
+                method: 'POST',
+                body: { reaction: args.reaction },
+            });
+            return text(`Reaction "${args.reaction}" added to message ${args.messageId} in conversation ${args.token}.`);
+        }
+        catch (err) {
+            return wrapError('reacting to message', err);
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// Export
+// ---------------------------------------------------------------------------
+export const talkTools = [
+    listConversationsTool,
+    listMessagesTool,
+    sendMessageTool,
+    createConversationTool,
+    listParticipantsTool,
+    addParticipantTool,
+    removeParticipantTool,
+    deleteMessageTool,
+    createPollTool,
+    reactToMessageTool,
+];

package/dist/tools/apps/translate.js

@@ -0,0 +1,79 @@
+import { z } from 'zod';
+import { fetchOCS } from '../../client/ocs.js';
+// ---------------------------------------------------------------------------
+// translate_text
+// ---------------------------------------------------------------------------
+export const translateTextTool = {
+    name: 'translate_text',
+    description: "Translate text between languages using Nextcloud's configured translation provider. If called without text, returns available language pairs.",
+    inputSchema: z.object({
+        text: z
+            .string()
+            .optional()
+            .describe('Text to translate. Omit to list available language pairs.'),
+        fromLanguage: z.string().optional().describe("Source language code (e.g. 'en', 'de', 'fr')"),
+        toLanguage: z.string().optional().describe("Target language code (e.g. 'en', 'de', 'fr')"),
+    }),
+    handler: async (args) => {
+        try {
+            // List available languages mode
+            if (!args.text) {
+                const data = await fetchOCS('/ocs/v2.php/translation/languages');
+                const languages = data.ocs.data.languages ?? [];
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: languages.length === 0
+                                ? 'No translation providers are configured in Nextcloud.'
+                                : JSON.stringify(languages, null, 2),
+                        },
+                    ],
+                };
+            }
+            // Translate mode
+            if (!args.fromLanguage || !args.toLanguage) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'Both fromLanguage and toLanguage are required when translating text.',
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const data = await fetchOCS('/ocs/v2.php/translation/translate', {
+                method: 'POST',
+                body: {
+                    text: args.text,
+                    fromLanguage: args.fromLanguage,
+                    toLanguage: args.toLanguage,
+                },
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: data.ocs.data.text,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error translating text: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// Export
+// ---------------------------------------------------------------------------
+export const translateTools = [translateTextTool];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiquila-mcp",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "description": "AIquila - MCP server for Nextcloud integration with Claude AI",
   "type": "module",
   "main": "dist/index.js",