aiquila-mcp 0.2.8 → 0.2.10

package/dist/client/deck.js

@@ -0,0 +1,40 @@
+import { getNextcloudConfig } from '../tools/types.js';
+import { logger } from '../logger.js';
+import { ApiError } from './aiquila.js';
+/**
+ * Make an authenticated request to the Nextcloud Deck REST API v1.0.
+ *
+ * Base path: /index.php/apps/deck/api/v1.0
+ */
+export async function fetchDeckAPI(endpoint, options = {}) {
+    const config = getNextcloudConfig();
+    const auth = Buffer.from(`${config.user}:${config.password}`).toString('base64');
+    let url = `${config.url}/index.php/apps/deck/api/v1.0${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 }, '[deck] 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/index.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 import { startStdio } from './transports/stdio.js';
 import { startHttp } from './transports/http.js';
 import { logger } from './logger.js';

package/dist/server.js

@@ -13,10 +13,13 @@ import { searchTools } from './tools/system/search.js';
 import { tasksTools } from './tools/apps/tasks.js';
 import { calendarTools } from './tools/apps/calendar.js';
 import { cookbookTools } from './tools/apps/cookbook.js';
+import { deckTools } from './tools/apps/deck.js';
 import { notesTools } from './tools/apps/notes.js';
 import { aiquilaTools } from './tools/apps/aiquila.js';
 import { usersTools } from './tools/apps/users.js';
 import { groupsTools } from './tools/apps/groups.js';
+import { circlesTools } from './tools/apps/circles.js';
+import { photosTools } from './tools/apps/photos.js';
 import { sharesTools } from './tools/apps/shares.js';
 import { contactsTools } from './tools/apps/contacts.js';
 import { mailTools } from './tools/apps/mail.js';
@@ -39,10 +42,13 @@ const allToolSets = [
     calendarTools,
     tasksTools,
     cookbookTools,
+    deckTools,
     notesTools,
     aiquilaTools,
     usersTools,
     groupsTools,
+    circlesTools,
+    photosTools,
     appsTools,
     occTools,
     securityTools,

package/dist/tools/apps/circles.js

@@ -0,0 +1,285 @@
+import { z } from 'zod';
+import { fetchOCS } from '../../client/ocs.js';
+/**
+ * Nextcloud Circles (Teams) Tools
+ *
+ * Manages circles/teams and their members via the Circles OCS API.
+ */
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const API_BASE = '/ocs/v2.php/apps/circles';
+const MEMBER_TYPE_LABELS = {
+    1: 'user',
+    2: 'group',
+    4: 'mail',
+    8: 'contact',
+    16: 'circle',
+};
+const MEMBER_LEVEL_LABELS = {
+    1: 'member',
+    4: 'moderator',
+    8: 'admin',
+    9: 'owner',
+};
+const CONFIG_FLAGS = [
+    [2, 'personal'],
+    [4, 'system'],
+    [8, 'visible'],
+    [16, 'open'],
+    [32, 'invite'],
+    [64, 'request-to-join'],
+    [128, 'friend'],
+    [256, 'password-protected'],
+    [512, 'no-owner'],
+    [1024, 'hidden'],
+    [4096, 'local'],
+    [32768, 'federated'],
+];
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+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)}`);
+}
+function formatConfigFlags(config) {
+    const active = CONFIG_FLAGS.filter(([bit]) => config & bit).map(([, label]) => label);
+    return active.length ? active.join(', ') : 'default';
+}
+function formatCircle(c) {
+    const owner = c.owner?.displayName ?? c.owner?.userId ?? 'unknown';
+    return `[${c.id}] ${c.displayName || c.name} (owner: ${owner}, config: ${formatConfigFlags(c.config)})`;
+}
+function formatMember(m) {
+    const type = MEMBER_TYPE_LABELS[m.userType] ?? `type-${m.userType}`;
+    const level = MEMBER_LEVEL_LABELS[m.level] ?? `level-${m.level}`;
+    return `[${m.id}] ${m.displayName || m.userId} (${type}, ${level}, status: ${m.status})`;
+}
+// ---------------------------------------------------------------------------
+// circles_list
+// ---------------------------------------------------------------------------
+export const circlesListTool = {
+    name: 'circles_list',
+    description: 'List all circles/teams accessible to the current user. Returns circle IDs, names, owners, and configuration.',
+    inputSchema: z.object({
+        limit: z.number().optional().describe('Maximum number of circles to return'),
+        offset: z.number().optional().describe('Offset for pagination'),
+    }),
+    handler: async (args) => {
+        try {
+            const queryParams = {};
+            if (args.limit !== undefined)
+                queryParams.limit = String(args.limit);
+            if (args.offset !== undefined)
+                queryParams.offset = String(args.offset);
+            const result = await fetchOCS(`${API_BASE}/circles`, { queryParams });
+            const circles = result.ocs.data;
+            if (!circles.length)
+                return text('No circles found.');
+            return text(`Circles (${circles.length}):\n${circles.map(formatCircle).join('\n')}`);
+        }
+        catch (err) {
+            return wrapError('listing circles', err);
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// circles_get
+// ---------------------------------------------------------------------------
+export const circlesGetTool = {
+    name: 'circles_get',
+    description: 'Get detailed information about a specific circle/team, including its description, owner, and configuration flags.',
+    inputSchema: z.object({
+        circleId: z.string().describe('The circle ID to retrieve'),
+    }),
+    handler: async (args) => {
+        try {
+            const result = await fetchOCS(`${API_BASE}/circles/${encodeURIComponent(args.circleId)}`);
+            const c = result.ocs.data;
+            const lines = [
+                `# ${c.displayName || c.name}`,
+                '',
+                `ID: ${c.id}`,
+                `Owner: ${c.owner?.displayName ?? c.owner?.userId ?? 'unknown'}`,
+                `Config: ${formatConfigFlags(c.config)}`,
+            ];
+            if (c.description)
+                lines.push(`Description: ${c.description}`);
+            if (c.members?.length) {
+                lines.push('', `Members (${c.members.length}):`);
+                lines.push(...c.members.map(formatMember));
+            }
+            return text(lines.join('\n'));
+        }
+        catch (err) {
+            return wrapError(`getting circle "${args.circleId}"`, err);
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// circles_create
+// ---------------------------------------------------------------------------
+export const circlesCreateTool = {
+    name: 'circles_create',
+    description: 'Create a new circle/team. The current user becomes the owner. Set personal=true for a private circle only visible to the owner.',
+    inputSchema: z.object({
+        name: z.string().describe('Name for the new circle'),
+        personal: z.boolean().optional().describe('Create as a personal circle (default: false)'),
+        local: z
+            .boolean()
+            .optional()
+            .describe('Restrict to local instance, no federation (default: false)'),
+    }),
+    handler: async (args) => {
+        try {
+            const body = { name: args.name };
+            if (args.personal)
+                body.personal = 1;
+            if (args.local)
+                body.local = 1;
+            const result = await fetchOCS(`${API_BASE}/circles`, {
+                method: 'POST',
+                jsonBody: body,
+            });
+            const c = result.ocs.data;
+            return text(`Circle created: [${c.id}] ${c.displayName || c.name}`);
+        }
+        catch (err) {
+            return wrapError('creating circle', err);
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// circles_delete
+// ---------------------------------------------------------------------------
+export const circlesDeleteTool = {
+    name: 'circles_delete',
+    description: 'Delete a circle/team. Requires owner privileges.',
+    inputSchema: z.object({
+        circleId: z.string().describe('The circle ID to delete'),
+    }),
+    handler: async (args) => {
+        try {
+            await fetchOCS(`${API_BASE}/circles/${encodeURIComponent(args.circleId)}`, {
+                method: 'DELETE',
+            });
+            return text(`Circle "${args.circleId}" has been deleted.`);
+        }
+        catch (err) {
+            return wrapError(`deleting circle "${args.circleId}"`, err);
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// circles_list_members
+// ---------------------------------------------------------------------------
+export const circlesListMembersTool = {
+    name: 'circles_list_members',
+    description: 'List all members of a circle/team. Returns member IDs (needed for removal), user IDs, types, and permission levels.',
+    inputSchema: z.object({
+        circleId: z.string().describe('The circle ID to list members for'),
+    }),
+    handler: async (args) => {
+        try {
+            const result = await fetchOCS(`${API_BASE}/circles/${encodeURIComponent(args.circleId)}/members`);
+            const members = result.ocs.data;
+            if (!members.length)
+                return text('No members found in this circle.');
+            return text(`Members (${members.length}):\n${members.map(formatMember).join('\n')}`);
+        }
+        catch (err) {
+            return wrapError(`listing members of circle "${args.circleId}"`, err);
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// circles_add_member
+// ---------------------------------------------------------------------------
+export const circlesAddMemberTool = {
+    name: 'circles_add_member',
+    description: 'Add a member to a circle/team. Requires moderator privileges or higher. Member type: 1=user (default), 2=group, 4=mail, 16=circle.',
+    inputSchema: z.object({
+        circleId: z.string().describe('The circle ID to add the member to'),
+        userId: z.string().describe('The user ID (or entity identifier) to add'),
+        type: z
+            .number()
+            .optional()
+            .describe('Member type: 1=user (default), 2=group, 4=mail, 8=contact, 16=circle'),
+    }),
+    handler: async (args) => {
+        try {
+            await fetchOCS(`${API_BASE}/circles/${encodeURIComponent(args.circleId)}/members`, {
+                method: 'POST',
+                jsonBody: { userId: args.userId, type: args.type ?? 1 },
+            });
+            const typeLabel = MEMBER_TYPE_LABELS[args.type ?? 1] ?? 'user';
+            return text(`Added ${typeLabel} "${args.userId}" to circle "${args.circleId}".`);
+        }
+        catch (err) {
+            return wrapError(`adding member "${args.userId}" to circle "${args.circleId}"`, err);
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// circles_remove_member
+// ---------------------------------------------------------------------------
+export const circlesRemoveMemberTool = {
+    name: 'circles_remove_member',
+    description: 'Remove a member from a circle/team. Use circles_list_members to get the memberId. Requires moderator privileges or higher.',
+    inputSchema: z.object({
+        circleId: z.string().describe('The circle ID to remove the member from'),
+        memberId: z.string().describe('The member ID (from circles_list_members), not the user ID'),
+    }),
+    handler: async (args) => {
+        try {
+            await fetchOCS(`${API_BASE}/circles/${encodeURIComponent(args.circleId)}/members/${encodeURIComponent(args.memberId)}`, { method: 'DELETE' });
+            return text(`Member "${args.memberId}" removed from circle "${args.circleId}".`);
+        }
+        catch (err) {
+            return wrapError(`removing member "${args.memberId}" from circle "${args.circleId}"`, err);
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// circles_search
+// ---------------------------------------------------------------------------
+export const circlesSearchTool = {
+    name: 'circles_search',
+    description: 'Search for circles/teams by name.',
+    inputSchema: z.object({
+        term: z.string().describe('Search term to match against circle names'),
+    }),
+    handler: async (args) => {
+        try {
+            const result = await fetchOCS(`${API_BASE}/search`, {
+                queryParams: { term: args.term },
+            });
+            const circles = result.ocs.data;
+            if (!circles.length)
+                return text(`No circles found matching "${args.term}".`);
+            return text(`Search results (${circles.length}):\n${circles.map(formatCircle).join('\n')}`);
+        }
+        catch (err) {
+            return wrapError('searching circles', err);
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// Export
+// ---------------------------------------------------------------------------
+export const circlesTools = [
+    circlesListTool,
+    circlesGetTool,
+    circlesCreateTool,
+    circlesDeleteTool,
+    circlesListMembersTool,
+    circlesAddMemberTool,
+    circlesRemoveMemberTool,
+    circlesSearchTool,
+];